void QuickSort(double a[2][N],int p,int r){ if (p<r){ int q=partion(a,p,r); QuickSort(a,p,q-1); QuickSort(a,q+1,r); } }
static void quicksort(int * array, int lower, int upper){ if(lower<upper){ int pivot = partion(array,lower,upper); quicksort(array,lower,pivot-1); quicksort(array,pivot+1,upper); } }
void quickSort(std::vector<int> &vec, int lo, int hi) { if (2 > hi - lo) return; int pivot = partion(vec, lo, hi - 1); quickSort(vec, lo, pivot); quickSort(vec, pivot + 1, hi); }
void quicksort(int *a, int left, int right) { if (left<right)//加上这个,不然有死循环,造成堆栈溢出 { int i = partion(a,left,right); quicksort(a,left,i-1); quicksort(a,i+1,right); } }
void quickSort(int* array, int n) { int part = partion(array, n); if (part > 0) { quickSort(array, part); } if (part + 1 < n) { quickSort(array + part + 1, n - (part + 1)); } }
// quickSort void quickSort(int arr[], int low, int high) { if (low < high) { int k = partion(arr, low, high); quickSort(arr, low, k - 1); quickSort(arr, low + 1, high); } }
void Quick_Sort::process_sort(int* array,int beg,int end) { if(beg < end && array != NULL) { int k = partion(array,beg,end); process_sort(array,beg,k-1); process_sort(array,k+1,end); } }
void quick_sort(int array[], int start, int end) { int pivot; if (start < end) { pivot = partion(array, start, end); quick_sort(array, start, pivot-1); quick_sort(array, pivot+1, end); } }
/** * find the k'th smallest elemnt from array who's contains 'length' elements. * @param array * @param length * @param k */ int liner_time_select(int array[], int low, int high, int k) { if (low == high)return array[low]; int i = partion(array, low, high); int j = i - low + 1; if (k <= j) { // the k'th smallest element is here. return liner_time_select(array, low, i, k); } else { return liner_time_select(array, i + 1, high, k - j); } }
void quick_sort(int arr[], int p, int q) { int j; if (p < q) { j = partion(arr, p, q); quick_sort(arr, p, j-1); quick_sort(arr, j+1, q); } }
void quick_sort(int *a, int len) { int pivot; if(len>0) { pivot = partion(a, len); quick_sort(a, pivot); quick_sort(&a[pivot+1], len-(pivot+1)); } }
int partion(vector<int> &nums, int b, int e, int k) // [b, e] { if(b >= e || k <= 0)return nums[b]; int i = b; for(int j = b + 1;j <= e;++j) { if (nums[j] >= nums[b]) { i++; swap(nums[i], nums[j]); } } swap(nums[b], nums[i]); if(i - b + 1 == k) return nums[i]; else if(i - b + 1 > k) return partion(nums, b, i , k); else return partion(nums, i + 1, e, k - (i - b + 1)); }
int quicksort(int *p,int low,int high) { if(low < high) { int mid=partion(p,low,high); quicksort(p,mid+1,high); quicksort(p,low,mid-1); return 1; } else return 0; }
int qsort(int *data,int begin,int end) { if(begin >= end) return 0; int i = partion(data,begin,end); printf("partion : %d \n",i); show(data,10); getchar(); qsort(data,begin,i-1); qsort(data,i+1,end); return 0; }
int find_min_k_nrs_by_partition(int *array, int size, int k, int *result) { assert(array && result); if (k <= 0) { return 0; } if (k >= size) { memcpy(result, array, size*sizeof(*array)); return size; } int *a = array; int s = size; int c = k; int ret; while (1) { if (s > 2) { ret = partion(a, s, c); if (ret == c) { // from a[0] to a[ret] are the smallest k numbers break; } else if (ret > c) { // continue partion s = ret; } else { // a[0] .. a[ret] are the results. we need to find others a = a + ret; s = s-ret; c = c - ret; } } else if (s == 2) { if (a[0] >= a[1]) { std::swap(a[0], a[1]); } break; } else { break; } } //Now array[0]~array[k] are smallest memcpy(result, array, k*sizeof(*array)); return k; }
/* * param k : description of k * param nums : description of array and index 0 ~ n-1 * return: description of return */ int kthLargestElement(int k, vector<int> nums) { // write your code here if(k <= 0 || k > nums.size())return -1; return partion(nums, 0, nums.size() - 1, k); }