Big-O Notation describes the limiting behavior when n is large, also known as asymptotic behavior. This is an approximation. (See http://en.wikipedia.org/wiki/Big_O_notation) Insertion sort is faster for small n because Quick Sort has extra overhead from the recursive function calls. Insertion sort is also more stable than Quick sort and requires less memory. This question describes … Read more
To answer the question of “Why does Hoare partitioning work?”: Let’s simplify the values in the array to just three kinds: L values (those less than the pivot value), E values (those equal to the pivot value), and G value (those larger than the pivot value). We’ll also give a special name to one location … Read more
What a and b are is clearly stated in the documentation for qsort: these are pointers that point to array elements that have to be compared. Comparison function in this case knows that the array elements are of type int. So it casts the void * pointers to int * type and performs a tri-state … Read more
I find this in the Java doc. The sorting algorithm is a Dual-Pivot Quicksort by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm offers O(n log(n)) performance on many data sets that cause other quicksorts to degrade to quadratic performance, and is typically faster than traditional (one-pivot) Quicksort implementations. Then I find this in … Read more
How does the comparator work? I’m not sure wether this was part of the question, but to be clear about how the comparator works: You have an order specified by ordered list $order and a special comparator callback list_cmp which (should) return wether argument $a is smaller than $b (return -1 or a value < … Read more
One of the major factors is that quicksort has better locality of reference — the next thing to be accessed is usually close in memory to the thing you just looked at. By contrast, heapsort jumps around significantly more. Since things that are close together will likely be cached together, quicksort tends to be faster. … Read more
For LINQ to Objects, it’s a stable quicksort that is used. For any other kind of LINQ, it’s left to the underlying implementation.
This “quicksort” is actually deforested tree sort: http://www.reddit.com/r/programming/comments/2h0j2/real_quicksort_in_haskell data Tree a = Leaf | Node a (Tree a) (Tree a) mkTree [] = Leaf mkTree (x:xs) = Node x (mkTree (filter (<= x) xs)) (mkTree (filter (x <) xs)) Binary tree is unbalanced, so O(N^2) worst-case and O(N*Log N) average-case complexity for building search tree. … Read more
The Original Haskell Code There are two issues with the Haskell version: You’re using string IO, which builds linked lists of characters You’re using a non-quicksort that looks like quicksort. This program takes 18.7 seconds to run on my Intel Core2 2.5 GHz laptop. (GHC 7.4 using -O2) Daniel’s ByteString Version This is much improved, … Read more
Heapsort is O(N log N) guaranted, what is much better than worst case in Quicksort. Heapsort doesn’t need more memory for another array to putting ordered data as is needed by Mergesort. So why do comercial applications stick with Quicksort? What Quicksort has that is so special over others implementations? I’ve tested the algorithms myself … Read more