# 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} }

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

#### Figures and Topics from this paper

#### 13 Citations

Average-case analysis of QuickSort and Binary Insertion Tree height using incompressibility

- Mathematics, Computer Science
- Inf. Process. Lett.
- 2007

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

- Mathematics
- 2009

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 sorting… Expand

Encoding Arguments

- Computer Science, Mathematics
- ACM Comput. Surv.
- 2017

“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

- Computer Science
- 2014

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

- 2016

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 impossible… Expand

A Brief on Short Descriptions

- Mathematics, Computer Science
- SIGA
- 2016

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

- Computer Science
- CSEDU
- 2013

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

- Economics
- 2011

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 focuses… Expand

A C++ App for Demonstration of Sorting Algorithms on Mobile Platforms

- Computer Science
- Int. J. Interact. Mob. Technol.
- 2014

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

- Engineering
- 2014

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 level… Expand

#### References

SHOWING 1-10 OF 59 REFERENCES

Average-case analysis of algorithms using Kolmogorov complexity

- Computer Science
- Journal of Computer Science and Technology
- 2008

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

- Mathematics, Computer Science
- ICALP
- 1999

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

- Mathematics, Computer Science
- Inf. Process. Lett.
- 2001

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

- Computer Science
- ESA
- 1996

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

- Mathematics, Computer Science
- J. Algorithms
- 1993

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))

- Computer Science
- SIGACT News
- 1997

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

- Computer Science, Mathematics
- 24th Annual Symposium on Foundations of Computer Science (sfcs 1983)
- 1983

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

- Computer Science
- Outstanding Dissertations in the Computer Sciences
- 1972

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

- Computer Science
- Comput. J.
- 1999

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

- Computer Science
- CACM
- 1959

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