quicksort

I watched the talk Three Beautiful Quicksorts and was messing around with quicksort. My implementation in python was very similar to c (select pivot, partition around it and recursing over smaller and larger partitions). Which I thought wasn't pythonic . So this is the implementation using list comprehension in python. def qsort(list): if list == []: return [] pivot = list[0] l = qsort([x for x in list[1:] if x < pivot]) u = qsort([x for x in list[1:] if x >= pivot]) return l + [pivot] + u Lets call the recursion metho qsortR. now I noticed that qsortR runs much slower than qsort for large(r)

I found this sample code online, which explains how the qsort function works. I could not understand what the compare function returns. #include "stdlib.h" int values[] = { 88, 56, 100, 2, 25 }; int cmpfunc (const void * a, const void * b) //what is it returning? { return ( *(int*)a - *(int*)b ); //What is a and b? } int main(int argc, _TCHAR* argv[]) { int n; printf("Before sorting the list is: \n"); for( n = 0 ; n < 5; n++ ) { printf("%d ", values[n]); } qsort(values, 5, sizeof(int), cmpfunc); printf("\nAfter sorting the list is: \n"); for( n = 0 ; n < 5; n++ ) { printf("%d ", values[n]); }

Once again I'm stuck when using openMP in C++. This time I'm trying to implement a parallel quicksort. Code: #include <iostream> #include <vector> #include <stack> #include <utility> #include <omp.h> #include <stdio.h> #define SWITCH_LIMIT 1000 using namespace std; template <typename T> void insertionSort(std::vector<T> &v, int q, int r) { int key, i; for(int j = q + 1; j <= r; ++j) { key = v[j]; i = j - 1; while( i >= q && v[i] > key ) { v[i+1] = v[i]; --i; } v[i+1] = key; } } stack<pair<int,int> > s; template <typename T> void qs(vector<T> &v, int q, int r) { T pivot; int i = q - 1, j = r; /

The worst-case running time of insertion on a red-black tree is O(lg n) and if I perform a in-order walk on the tree, I essentially visit each node, so the total worst-case runtime to print the sorted collection would be O(n lg n) I am curious, why are red-black trees not preferred for sorting over quick sort (whose average-case running time is O(n lg n) . I see that maybe because red-black trees do not sort in-place, but I am not sure, so maybe someone could help. Knowing which sort algorithm performs better really depend on your data and situation. If you are talking in general/practical

I read the following in a forum : Merge sort is very efficient for immutable datastructures like linked lists and Quick sort is typically faster than merge sort when the data is stored in memory. However, when the data set is huge and is stored on external devices such as a hard drive, merge sort is the clear winner in terms of speed. It minimizes the expensive reads of the external drive and when operating on linked lists, merge sort only requires a small constant amount of auxiliary storage Can someone help me understand the above argument? why is merge sort preferred for sorting huge linked