Analysis of Sorting Algorithms by Kolmogorov Complexity (A Survey)

@article{Vitnyi2009AnalysisOS,
  title={Analysis of Sorting Algorithms by Kolmogorov Complexity (A Survey)},
  author={Paul M. B. Vit{\'a}nyi},
  journal={ArXiv},
  year={2009},
  volume={abs/0905.4452}
}
  • P. Vitányi
  • Published 27 May 2009
  • Mathematics, Computer Science
  • ArXiv
Recently, many results on the computational complexity of sorting algorithms were obtained using Kolmogorov complexity (the incompressibility method). Especially, the usually hard average-case analysis is ammenable to this method. Here we survey such results about Bubblesort, Heapsort, Shellsort, Dobosiewiczsort, Shakersort, and sorting with stacks and queues in sequential or parallel mode. Especially in the case of Shellsort the uses of Kolmogorov complexity surprisingly easily resolved… Expand
Average-case analysis of QuickSort and Binary Insertion Tree height using incompressibility
TLDR
A simple incompressibility argument is obtained that yields an asymptotic analysis of the average height of a Binary Insertion Tree, which implies that the QuickSort algorithm sorts a permutation of n elements in @Q(nlgn) comparisons on average. Expand
The Folklore of Sorting Algorithms
The objective of this paper is to review the folklore knowledge seen in research work devoted on synthesis, optimization, and effectiveness of various sorting algorithms. We will examine sortingExpand
Encoding Arguments
TLDR
“Encoding arguments” provide an alternative presentation in which probabilistic reasoning is encapsulated in a “uniform encoding lemma” that provides an upper bound on the probability of an event using the fact that a uniformly random choice from a set of size n cannot be encoded with fewer than log 2n bits on average. Expand
Enhancement of Selection, Bubble and Insertion Sorting Algorithm
TLDR
A set of improved sorting algorithms are proposed which gives better performance and design idea and are analyzed using asymptotic analysis and also using machine-running time and compared with their basic sorting algorithms. Expand
SIGACT News Complexity Theory Column 90
We discuss research developments on the complexity of shortest programs since the turn of the millennium. In particular, we will delve into the phenomenon of list approximation: while it’s impossibleExpand
A Brief on Short Descriptions
TLDR
The phenomenon of list approximation is delved into: while it's impossible to compute the shortest description for a given string, the authors can efficiently generate a short list of candidates which includes a (nearly) shortest description. Expand
Demonstration of Sorting Algorithms on Mobile Platforms
TLDR
This paper presents a systematic approach to the implementation of a mobile framework for demonstrating of sorting algorithms, and implementations of Gnome Sort, Insertion Sort, and Quicksort are given as a portable C-style code. Expand
Bounded Rationality and the Emergence of Simplicity Amidst Complexity
The purpose of this essay is to explore the relationship between the simple and the complex in economics by anchoring our analysis on bounded rationality. Much of the conventional literature focusesExpand
A C++ App for Demonstration of Sorting Algorithms on Mobile Platforms
TLDR
This paper presents a systematic approach for designing a C++ app for demonstrating sorting algorithms on smartphones and tablets and the implementation of Insertion Sort is given as an example. Expand
Enterprises as Complex Systems: Extended Axiomatic Design Theory and its Application in Enterprise Architecture Practice
The concept of self-evolving/self-designing systems is defined using the notion of life cycle relationships. The authors propose that to design complex enterprises as systems of systems on each levelExpand
...
1
2
...

References

SHOWING 1-10 OF 59 REFERENCES
Average-case analysis of algorithms using Kolmogorov complexity
TLDR
Borders on the average-case number of stacks required for sorting sequential or parallel Queuesort or Stacksort are proved and the incompressibility method is developed. Expand
Average-Case Complexity of Shellsort
TLDR
A general lower bound on the average-case complexity of Shellsort is proved: the average number of data-movements made by a p-pass Shellsort for any incremental sequence is Ω(pn 1+1/p ) for every p. Expand
Analyzing variants of Shellsort
TLDR
It is proved that the worst-case time of Shaker sort is O(n3/2log3n) for certain sequences of increments and the average- case time for both variants is O (n2/cp) where p is the number of increments. Expand
Analysis of Shellsort and Related Algorithms
TLDR
The discussion includes: upper bounds, including linkages to number-theoretic properties of the algorithm; lower bounds on Shellsort and Shellsort-based networks; average-case results; proposed probabilistic sorting networks based on the algorithms; and a list of open problems. Expand
The Worst Case in Shellsort and Related Algorithms
  • B. Poonen
  • Mathematics, Computer Science
  • J. Algorithms
  • 1993
TLDR
This work shows that sorting a sufficiently long list of length N using Shellsort with m increments requires at least Nl+c/√m comparisons in the worst case and proves that Ω(N(log N/log log N)2) comparisons are needed regardless of the number of increments. Expand
Book Review: An introduction to Kolmogorov Complexity and its Applications Second Edition, 1997 by Ming Li and Paul Vitanyi (Springer (Graduate Text Series))
TLDR
The complexity of a string is defined as the shortest description of x, and a formal definition is given that is equivalent to the one in the book. Expand
Improved upper bounds on shellsort
  • J. Incerpi, R. Sedgewick
  • Computer Science, Mathematics
  • 24th Annual Symposium on Foundations of Computer Science (sfcs 1983)
  • 1983
TLDR
The running time of Shellsort, with the number of passes restricted to O(log N), was thought for some time to be Θ(N3/2), but a different approach is used to achieve O(N1+4/√2lgN). Expand
Shellsort and Sorting Networks
  • V. Pratt
  • Computer Science
  • Outstanding Dissertations in the Computer Sciences
  • 1972
TLDR
The author answers some open questions about the speed of Shellsort with certain characteristic sequences, and suggests a novel application ofShellsort, namely to sorting networks, which is approximately 1.5 times as fast as with previous methods. Expand
New Applications of the Incompressibility Method
TLDR
It is shown that the incompressibility method is particularly suited to obtain average-case computational complexity lower bounds, which have been difficult to obtain in the past by other methods. Expand
A high-speed sorting procedure
TLDR
It is highly desirable to have a method with the speed characteristics of the merging by pairs and the space characteristics of sifting, if such a method were available, to sort twice as many items at one time in the machine and still do it at a reasonably high speed. Expand
...
1
2
3
4
5
...