quicksort

I have a simple script written in both Python and Haskell. It reads a file with 1,000,000 newline separated integers, parses that file into a list of integers, quick sorts it and then writes it to a different file sorted. This file has the same format as the unsorted one. Simple. Here is Haskell: quicksort :: Ord a => [a] -> [a] quicksort [] = [] quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater) where lesser = filter (< p) xs greater = filter (>= p) xs main = do file <- readFile "data" let un = lines file let f = map (\x -> read x::Int ) un let done = quicksort f writeFile

Both quicksort and heapsort do in-place sorting. Which is better? What are the applications and cases in which either is preferred? DVK This paper has some analysis. Also, from Wikipedia: The most direct competitor of quicksort is heapsort. Heapsort is typically somewhat slower than quicksort, but the worst-case running time is always Θ(nlogn). Quicksort is usually faster, though there remains the chance of worst case performance except in the introsort variant, which switches to heapsort when a bad case is detected. If it is known in advance that heapsort is going to be necessary, using it

I learnt about quick sort and how it can be implemented in both Recursive and Iterative method. In Iterative method: Push the range (0...n) into the stack Partition the given array with a pivot Pop the top element. Push the partitions (index range) onto a stack if the range has more than one element Do the above 3 steps, till the stack is empty And the recursive version is the normal one defined in wiki. I learnt that recursive algorithms are always slower than their iterative counterpart. So, Which method is preferred in terms of time complexity (memory is not a concern)? Which one is fast

Heap Sort has a worst case complexity of O(nlogn) while Quicksort has O(n^2) . But emperical evidences say quicksort is superior. Why is that? 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. However, quicksort's worst-case performance is significantly worse than heapsort's is. Because some critical applications will require