/*
* 快速排序
*
* 不稳定排序
* 平均时间复杂度可证明为：O(N * logN)，最差时间复杂度：O(N^2)
* 空间复杂度：O(1)，若考虑栈最好情况为为：O(logN)，最差为：O(N)
* 复杂度分析：http://blog.csdn.net/hn_gsf/article/details/52249621
*/
#include <stdio.h>
void swap(int *data, int l, int r) {
int t = data[l];
data[l] = data[r];
data[r] = t;
}
/*
* 实现方式 1
*
* 思想：每次在待排序区间 [l, r] 选定一个基准值 data[x]，将比 data[x] 小的数放在 data[x] 左边，比 data[x] 大的数放在右边，经过处理后 data[x] 的位置就唯一了，其下标记为 m，然后递归处理区间 [l, m-1]、[m+1, r]
* 实现：每次使用两个指针 i=l, j=r，循环处理，j-- 向左，当找到比 data[x] 小的数将其交换到左边，i++ 向右，当找到比 data[i] 大的数将其交换到右边，当 i=j 时即满足 data[l..i-1] < data[i=j] < data[j+1..r]
*
* 在最优情况下，递归深度为 logN 层，每层处理的时间复杂度为 O(N)，即总复杂度为 O(N * logN)
* 在最差情况下，即待排序数组为正序或倒序时，需要递归 n-1 层，即每次划分的时候只单向移动一个单位，即分治退化成链，每层需要比较 n-i 次，总时间复杂度为 O(N^2)
*
* 举例：
*
* 取 data[x]=data[l]=5
*
* l r
* i j
* 5 9 8 2 4 7 1 3 6
*
* i j <=
* 5 9 8 2 4 7 1 3 6
* 3 9 8 2 4 7 1 5 6 找到第一个比 5 小的数 3，交换 3 到左边
*
* i j =>
* 3 9 8 2 4 7 1 5 6
* 3 5 8 2 4 7 1 9 6 找到第一个比 5 大的数 9，交换 9 到右边
*
* i j <=
* 3 5 8 2 4 7 1 9 6
* 3 1 8 2 4 7 5 9 6 找到第一个比 5 小的数 1，交换 1 到左边
*
* i j =>
* 3 1 8 2 4 7 5 9 6
* 3 1 5 2 4 7 8 9 6 找到第一个比 5 大的数 8，交换 8 到右边
*
* i j <=
* 3 1 5 2 4 7 8 9 6
* 3 1 4 2 5 7 8 9 6 找到第一个比 5 小的数 4，交换 4 到左边
*
* ij
* 3 1 4 2 5 7 8 9 6
*
* 具体实现上有点细微的区别，每次交换的数都是 data[x]，所以并不需要真正交换，直接赋值即可，最后将 i=j 处赋值回 data[x] 即可：
*
* l r
* i j
* 5 9 8 2 4 7 1 3 6
*
* i j
* 3 9 8 2 4 7 1 _ 6
*
* i j
* 3 _ 8 2 4 7 1 9 6
*
* i j
* 3 1 8 2 4 7 _ 9 6
*
* i j
* 3 1 _ 2 4 7 8 9 6
*
* i j
* 3 1 4 2 _ 7 8 9 6
*
* ji
* 3 1 4 2 5 7 8 9 6
*
* 最差时间复杂度举例：
*
* l r
* i j
* 1 2 3 4 5 6 7 8 9
*
* i j
* 2 3 4 5 6 7 8 9
*
* i j
* 3 4 5 6 7 8 9
*
* ...
*
*/
void quick_sort_1(int *data, int l, int r) {
if (l < r) {
// 此处可随机基准值防止最坏情况：交换 l 和后面某个位置的值
// int pivot = (l + r) >> 1;
// swap(data, l, pivot);
int i = l, j = r, tmp = data[l];
while (i != j) {
while (j > i && data[j] >= tmp) j--; // 右边如果比基准值大，则不需要交换，j 继续向左
data[i] = data[j]; // 找到第一个需要交换的 j，交换到左边
while (i < j && data[i] <= tmp) i++; // 左边如果比基准值小，则不需要交换，i 继续向右
data[j] = data[i]; // 找到第一个需要交换的 i，交换到右边
}
data[i] = tmp;
quick_sort_1(data, l, i - 1);
quick_sort_1(data, i + 1, r);
}
}
/*
* 实现方式 2
*
* 实现 1 中其实是直接与基准值本身进行交换，比如：[5] 1 8 2 3 6 => 3 1 8 2 [5] 6 => 3 1 [5] 2 8 6 => 3 1 2 [5] 8 6
*
* 这里不同的循环将左边比基准值大的数和右边比基准值小的数进行交换，循环结束时除了基准值外满足排序要求，且此时 i=j 指向从右往左第一个比基准值小的数，于是将其和基准值交换即使得满足最终要求
*
* 举例：
*
* l r
* i j
* 5 9 8 2 4 7 1 3 6
*
* i j
* 5 9 8 2 4 7 1 3 6 从右到左找到第一个比 5 小的数 3，从左到右找到第一个比 5 大的数，将两者进行交换
* 5 3 8 2 4 7 1 9 6
*
* i j
* 5 3 8 2 4 7 1 9 6
* 5 3 1 2 4 7 8 9 6
*
* ij
* 5 3 1 2 4 7 8 9 6 循环停止时的序列，i=j，4 < 5，所以直接将 5 和 data[ij] 交换
* 4 3 1 2 5 7 8 9 6
*/
void quick_sort_2(int data[], int l, int r) {
if (l < r) {
int i = l, j = r, tmp = data[l];
while (i < j) {
while (j > i && data[j] >= tmp) j--; // 不需要交换，j 继续向左
while (i < j && data[i] <= tmp) i++; // 不需要交换，i 继续向右
if (i != j) { // 交换
int t = data[i];
data[i] = data[j];
data[j] = t;
}
}
swap(data, l, i); // 最后将基准值换到 i=j 处使得满足最终条件
quick_sort_2(data, l, i - 1);
quick_sort_2(data, i + 1, r);
}
}
/*
* 实现方式 3，实现起来更简单
*
* 思想和方式 2 差不多，不同的时在实现上只需要用一个指针从左到右处理，遇到右边有比基准值更小的数则挨着基准值依次交换到左边，最后将基准值同最后一个比基准值小的数进行交换达到排序要求
*
* 举例：
*
* l i r
* 5 9 8 2 4 7 1 3 6
*
* l i
* 5 9 8 2 4 7 1 3 6 遇到一个比 5 小的数 2，交换到左边
* 5 2 8 9 4 7 1 3 6
* la i
*
* l la i
* 5 2 8 9 4 7 1 3 6 遇到一个比 5 小的数 4，依次交换到左边
* 5 2 4 9 8 7 1 3 6
* la
*
* l la i
* 5 2 4 9 8 7 1 3 6 遇到一个比 5 小的数 1，依次交换到左边
* 5 2 4 1 8 7 9 3 6
* la
*
* l la i
* 5 2 4 1 8 7 9 3 6 遇到一个比 5 小的数 3，依次交换到左边
* 5 2 4 1 3 7 9 8 6
* la
*
* l la i
* 5 2 4 1 3 7 9 8 6 last 表示比基准值小的上一个数，所以这里将其和基准值交换
* 3 2 4 1 5 7 9 8 6
*/
void quick_sort_3(int data[], int l, int r) {
if (l < r) {
int last = l;
for (int i = l + 1; i <= r; i++) { // 从左向右处理
if (data[i] < data[l]) { // 遇到右边有比基准值更小的数则挨着基准值依次交换到左边
swap(data, ++last, i);
}
}
swap(data, l, last); // 与基准值交换
quick_sort_3(data, l, last - 1);
quick_sort_3(data, last + 1, r);
}
}
/*
* 利用快排的思想查找第 k 大或前 k 大
* 平均复杂度：O(n)
*
* 第 k 大，倒序排序
* 第 k 小，正序排序
*/
int find_kth(int data[], int l, int r, int k) {
if (l < r) {
int i = l, j = r, tmp = data[l];
while (i != j) {
while (j > i && data[j] <= tmp) j--;
data[i] = data[j];
while (i < j && data[i] >= tmp) i++;
data[j] = data[i];
}
data[i] = tmp;
if (k == i) return data[i]; // 如果 data[i] 最终就在第 k 个数处
else if (k < i) return find_kth(data, l, i - 1, k); // 如果在左边，递归处理左边
else return find_kth(data, i + 1, r, k); // 如果在右边，递归处理右边
}
return -1; // unreachable
}
void test_quick_sort_1() {
int a[] = {5, 9, 8, 2, 4, 7, 1, 3, 6};
quick_sort_1(a, 0, 8);
for (int i = 0; i < 8; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
void test_quick_sort_2() {
int a[] = {5, 9, 8, 2, 4, 7, 1, 3, 6};
quick_sort_2(a, 0, 8);
for (int i = 0; i < 8; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
void test_quick_sort_3() {
int a[] = {5, 9, 8, 2, 4, 7, 1, 3, 6};
quick_sort_3(a, 0, 8);
for (int i = 0; i < 8; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
void test_find_kth() {
int a[] = {5, 9, 8, 2, 4, 7, 1, 3, 6};
int ret = find_kth(a, 0, 8, 2); // 这里下标从 0 开始，定义第 0 大为 9，第 1 大为 8，第 2 大为 7...
printf("%d\n", ret);
}
int main() {
test_quick_sort_1();
test_quick_sort_2();
test_quick_sort_3();
test_find_kth();
return 0;
}
