Quicksort

Hoare, C. A. R.

doi:10.1093/comjnl/5.1.10

Cited by 799 publications

(449 citation statements)

References 0 publications

Supporting

Mentioning

431

Contrasting

Unclassified

Order By: Relevance

“…Hoare suggested in his paper [16] that it would be more efficient to use another sorting method when the subsequences are relatively small, since the overhead of the partitioning gets too large when dealing with small sequences. We decided to follow that suggestion and sort all subsequences that can fit in the available local shared memory using an alternative sorting method.…”

Section: Overviewmentioning

confidence: 99%

See 1 more Smart Citation

A Practical Quicksort Algorithm for Graphics Processors

Cederman

Tsigas

2008

Algorithms - ESA 2008

121

View full text Add to dashboard Cite

Abstract. In this paper we present GPU-Quicksort, an efficient Quicksort algorithm suitable for highly parallel multi-core graphics processors. Quicksort has previously been considered as an inefficient sorting solution for graphics processors, but we show that GPU-Quicksort often performs better than the fastest known sorting implementations for graphics processors, such as radix and bitonic sort. Quicksort can thus be seen as a viable alternative for sorting large quantities of data on graphics processors.

show abstract

Section: Overviewmentioning

confidence: 99%

“…By doing that, Hoare have showed [16] that the maximum recursive depth can never go below log 2 (n). We use an explicit stack as suggested by Hoare and implemented by Sedgewick, always storing the smallest subsequence at the top [17].…”

Section: Detailed Descriptionmentioning

confidence: 99%

A Practical Quicksort Algorithm for Graphics Processors

Cederman

Tsigas

2008

Algorithms - ESA 2008

121

View full text Add to dashboard Cite

show abstract

“…To demonstrate the capabilities of the CTB system, an implementation of the quick-sort partition algorithm [25], shown in Figure 3, was analysed. This method partitions a subsection of an array of integers a into two groups: only elements between indices low and high (inclusive) are processed.…”

Section: Analysis Of a Sample Methodsmentioning

confidence: 99%

Using symbolic execution to guide test generation

Lee

Morris

Parker

et al. 2005

Softw. Test. Verif. Reliab.

View full text Add to dashboard Cite

SUMMARYAlthough a number of weaknesses of symbolic execution, when used for software testing, have been highlighted in the literature, the recent resurgence of strongly-typed languages has created opportunities for re-examining symbolic execution to determine whether these shortfalls can be overcome. This paper discusses symbolic execution in general and makes two contributions: (a) overcoming one of the key problems, analysing programs with indexed arrays; and (b) describing the incorporation of a symbolic execution module for test case generation into an integrated testing tool. For methods which index arrays, a new approach determines all the possible values of each array index, allowing the generation of equivalence classes for every possible combination of array element aliases. An incremental simplification approach, which converts path expressions to canonical forms in order to identify infeasible paths at the earliest opportunity and thus reduce the analysis time, is also described. Symbolic execution is most effective when included in an integrated test and analysis environment: a component test bench was built with a symbolic execution module integrated into it, providing a toolbox of software component test and code analysis methods aimed at programmers at all levels.

show abstract

“…Proofs of the O(n log n) average-case complexity of Quicksort [1] are included in many textbooks on computational complexity [9, for example]. This paper documents what the authors believe to be the first fully formal machine-checked version of such a proof, developed using the Coq proof assistant [2].…”

Section: Introductionmentioning

confidence: 91%

A Machine-Checked Proof of the Average-Case Complexity of Quicksort in Coq

Weegen

McKinna

2009

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. As a case-study in machine-checked reasoning about the complexity of algorithms in type theory, we describe a proof of the average-case complexity of Quicksort in Coq. The proof attempts to follow a textbook development, at the heart of which lies a technical lemma about the behaviour of the algorithm for which the original proof only gives an intuitive justification.We introduce a general framework for algorithmic complexity in type theory, combining some existing and novel techniques: algorithms are given a shallow embedding as monadically expressed functional programs; we introduce a variety of operation-counting monads to capture worst-and average-case complexity of deterministic and nondeterministic programs, including the generalization to count in an arbitrary monoid; and we give a small theory of expectation for such non-deterministic computations, featuring both general map-fusion like results, and specific counting arguments for computing bounds.Our formalization of the average-case complexity of Quicksort includes a fully formal treatment of the 'tricky' textbook lemma, exploiting the generality of our monadic framework to support a key step in the proof, where the expected comparison count is translated into the expected length of a recorded list of all comparisons.

show abstract

Quicksort

Cited by 799 publications

References 0 publications

A Practical Quicksort Algorithm for Graphics Processors

A Practical Quicksort Algorithm for Graphics Processors

Using symbolic execution to guide test generation

A Machine-Checked Proof of the Average-Case Complexity of Quicksort in Coq

Contact Info

Product

Resources

About