/* * Sorts an array while keeping metadata in sync. * This sort is unstable and its average performance is * O(data.size() * log2(data.size()). * Input assertions: for any valid index 'i' in data, index 'i' is valid in * metadata. 'from' and 'to' are valid indices into data. 'to' can be * the maximum value for the type 'unsigned int'. * Invariant: index 'i' in metadata describes index 'i' in data. * Input: 'data', data to sort. * 'metadata', data describing the values in 'data'. * 'sortFunction', function determining the sort order of two elements. * 'from', index of the first element in the range to sort. * 'to', index of the last element in the range to sort. */ template <class Data, class Metadata> void quickSort(std::vector<Data>& data, std::vector<Metadata>& metadata, int (*sortFunction) (Data&, Data&), const unsigned int from, const unsigned int to) { if (isSorted(data, sortFunction, from, to)) return; unsigned int pivotIndex = choosePivot(data, sortFunction, from, to); unsigned int newPivotIndex = partition(data, metadata, sortFunction, from, to, pivotIndex); if (newPivotIndex > 0) quickSort(data, metadata, sortFunction, from, newPivotIndex - 1); if (newPivotIndex < to) quickSort(data, metadata, sortFunction, newPivotIndex + 1, to); }
/* ** QuickSort algorithm (recursive function) */ static void auxsort (lua_State *L, IdxT lo, IdxT up, unsigned int rnd) { while (lo < up) { /* loop for tail recursion */ IdxT p; /* Pivot index */ IdxT n; /* to be used later */ /* sort elements 'lo', 'p', and 'up' */ lua_geti(L, 1, lo); lua_geti(L, 1, up); if (sort_comp(L, -1, -2)) /* a[up] < a[lo]? */ set2(L, lo, up); /* swap a[lo] - a[up] */ else lua_pop(L, 2); /* remove both values */ if (up - lo == 1) /* only 2 elements? */ return; /* already sorted */ if (up - lo < RANLIMIT || rnd == 0) /* small interval or no randomize? */ p = (lo + up)/2; /* middle element is a good pivot */ else /* for larger intervals, it is worth a random pivot */ p = choosePivot(lo, up, rnd); lua_geti(L, 1, p); lua_geti(L, 1, lo); if (sort_comp(L, -2, -1)) /* a[p] < a[lo]? */ set2(L, p, lo); /* swap a[p] - a[lo] */ else { lua_pop(L, 1); /* remove a[lo] */ lua_geti(L, 1, up); if (sort_comp(L, -1, -2)) /* a[up] < a[p]? */ set2(L, p, up); /* swap a[up] - a[p] */ else lua_pop(L, 2); } if (up - lo == 2) /* only 3 elements? */ return; /* already sorted */ lua_geti(L, 1, p); /* get middle element (Pivot) */ lua_pushvalue(L, -1); /* push Pivot */ lua_geti(L, 1, up - 1); /* push a[up - 1] */ set2(L, p, up - 1); /* swap Pivot (a[p]) with a[up - 1] */ p = partition(L, lo, up); /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */ if (p - lo < up - p) { /* lower interval is smaller? */ auxsort(L, lo, p - 1, rnd); /* call recursively for lower interval */ n = p - lo; /* size of smaller interval */ lo = p + 1; /* tail call for [p + 1 .. up] (upper interval) */ } else { auxsort(L, p + 1, up, rnd); /* call recursively for upper interval */ n = up - p; /* size of smaller interval */ up = p - 1; /* tail call for [lo .. p - 1] (lower interval) */ } if ((up - lo) / 128 > n) /* partition too imbalanced? */ rnd = l_randomizePivot(); /* try a new randomization */ } /* tail call auxsort(L, lo, up, rnd) */ }
void quickSort(int *A, int left, int right, int length) { if (left >= right) { return; } int i = left + 1; int j = left + 1; int pivot = choosePivot(A, left, right); swap(A, pivot, left); while (j <= right) { if (A[j] < A[left]) { swap(A, i, j); i += 1; } j += 1; } swap(A, left, i - 1); printArray(A, length); quickSort(A, left, i - 2, length); quickSort(A, i, right, length); }
void quickSort(int *a, int left, int right) { int pivot, i, j; if(left < right) { swap(&a[left], &a[choosePivot(left, right)]); pivot = a[left]; i = left + 1; j = right; while(i <= j) { while((a[i] <= pivot) && (i <= right)) i++; while((a[j] > pivot) && (j >= left)) j--; if(i < j) swap(&a[i], &a[j]); } swap(&a[left], &a[j]); quickSort(a, left, j - 1); quickSort(a, j + 1, right); } }
void quickSort(PhoneCall *phoneCall, int left, int right) { int i, j; PhoneCall pivot; if(left < right) { swap(&phoneCall[left], &phoneCall[choosePivot(left, right)]); pivot = phoneCall[left]; i = left + 1; j = right; while(i <= j) { while((phoneCall[i].during <= pivot.during) && (i <= right)) i++; while((phoneCall[j].during > pivot.during) && (j >= left)) j--; if(i < j) swap(&phoneCall[i], &phoneCall[j]); } swap(&phoneCall[left], &phoneCall[j]); quickSort(phoneCall, left, j - 1); quickSort(phoneCall, j + 1, right); } }
void quicksort(int arr[], int left, int right) { test += (right - left - 1); int tmp; int l = left; int r = right; int pivot = choosePivot(l, r); do { while (arr[l] < arr[pivot]) { l++; } while (arr[r] > arr[pivot]) { r--; } if (l <= r) { tmp = arr[l]; arr[l] = arr[r]; arr[r] = tmp; l++; r--; } } while (l <= r); if (left < r) { quicksort(arr, left, r); } if (l < right) { quicksort(arr, l, right); } }