Two arguments come to my mind: Quicksort/Introsort is more flexible: Quicksort and Introsort work well with all kinds of data. All you need for sorting is the possibility to compare items. This is trivial with numbers but you can sort other data as well. Radix sort on the other hand just sorts things by their … Read more
You have simply hit the recursion limits. Your list of names is too large for Python’s limited recursion capabilities. Your Quicksort works just fine otherwise. You could raise the recursion limit by setting the limit higher with sys.setrecursionlimit(). You can set it a fair amount higher, but you do so at your own risk. A better option is … Read more
Radix sort is harder to generalize than most other sorting algorithms. It requires fixed size keys, and some standard way of breaking the keys into pieces. Thus it never finds its way into libraries.
Each partitioning operation takes O(n) operations (one pass on the array). In average, each partitioning divides the array to two parts (which sums up to log n operations). In total we have O(n * log n) operations. I.e. in average log n partitioning operations and each partitioning takes O(n) operations.
The true quicksort has two beautiful aspects: Divide and conquer: break the problem into two smaller problems. Partition the elements in-place. The short Haskell example demonstrates (1), but not (2). How (2) is done may not be obvious if you don’t already know the technique!
Let’s see if we can work this out! In merge sort, at each level of the recursion, we do the following: Split the array in half. Recursively sort each half. Use the merge algorithm to combine the two halves together. So how many comparisons are done at each step? Well, the divide step doesn’t make … Read more
Your local variable mid is declared in the scope that is closer to the point of use, so it “shadows” the mid() function; the compiler thinks that you are trying to “call” an integer, which is invalid. Rename the local variable to fix this problem: Note: you could also use ::mid(lo, hi) instead of renaming … Read more
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 … Read more
Intro to Algorithms from MIT Press qualifies QuickSort as in-place – it sorts the elements within the array with at most a constant amount of them outside the array at any given time. At the end of the day, people will always have differing opinions (is Top-Down Memoization considered Dynamic Programming? Not to some “classical” folks), side with who you … Read more
Your consideration is wrong. The value of r does not change, since it is given as value to the Quicksort function(not a reference). You handle the ranges with p,q such that p is the first index in the range and q the first index not in the range. Thus, your calls were wrong: Here is the complete example. I used std::swap to change elements and ans std::vector … Read more