void
quick_sort(int p[], int low, int high) {
int pivot;
if (low < high) {
pivot = quick_partition(p, low, high);
quick_sort(p, low, pivot - 1);
quick_sort(p, pivot + 1, high);
}
}
/*
* －－快速排序－－
* 快速排序的实现基于分治法，具体分为三个步骤。假设待排序的序列为L[m..n]。
* 分解：序列L[m .. n]被划分成两个可能为空的子序列L[m .. pivot-1]和L[pivot+1 .. n]，
* 使L[m .. pivot-1]的每个元素均小于或等于L[pivot]，同时L[pivot+1.. n]的每个元素均大于L[pivot]。
* 其中L[pivot]称为这一趟分割中的主元（也称为枢轴、支点）。
* 解决：通过递归调用快速排序，对子序列L[m .. pivot-1]和L[pivot+1 .. r]排序。
* 合并：由于两个子序列是就地排序的，所以对它们的合并不需要操作，整个序列L[m .. n]已排好序。
*/
void quick_sort(int v[], int low, int high)
{
int pivot_position;
if (low < high) {
pivot_position = quick_partition(v, low, high);
quick_sort(v, low, pivot_position - 1);
quick_sort(v, pivot_position + 1, high);
}
}
void quick_sort(int a[], int s, int e) {
if( s >= e) {
return;
}
int pivot = quick_partition(a, s, e);
printf("pivot -> %d\n", pivot);
if(pivot == -1) {
return;
}
quick_sort(a, s, pivot);
quick_sort(a, pivot+1, e);
}
int find_kth_largest(int a[], int n, int k) {
if(k >= n) {
return -1;
}
int pivot_idx = quick_partition(a, 0, n);
if(pivot_idx == -1) {
// fatal
return -1;
}
int reverse_idx = n - pivot_idx - 1;
if(reverse_idx == k) {
return a[pivot_idx];
}
return reverse_idx>k?find_kth_largest(a+pivot_idx+1, reverse_idx, k):find_kth_largest(a, pivot_idx, k-reverse_idx-1);
}
