排序算法——快速排序(单边，双边划分，随机划分 三位取中划分 通俗易懂 ）

算法思想

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

 (1)首先设定一个分界值，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。

1.从左到右遍历 （单边划分） 

动画演示:

单边划分思想代码

// 单边划分的快速排序算法，将数组 ar 中 [left, right] 区间的数进行排序
// 单边划分的思路是将数组分为两部分，左半部分的元素都小于枢轴元素，右半部分的元素都大于枢轴元素
int Parition_one(int* ar, int left, int right)
{
    assert(nullptr != ar); // 断言确保指针不为空
    int i = left, j = i + 1; // i 指向枢轴元素，j 指向右边待排序的第一个元素
    int tem = ar[i]; // 将枢轴元素保存在临时变量中
    while (j <= right) // 当 j 小于等于右边界时，进行循环
    {
        if (ar[j] < tem) { // 如果右边待排序的第一个元素小于枢轴元素
            ar[i] = ar[j]; // 将右边待排序的第一个元素和枢轴元素交换
            i += 1; // 将枢轴元素向右移动一位
            if (ar[i] >= tem) { // 如果枢轴元素已经到了最右边，跳出循环
                ar[j] = ar[i];
            }
        }
        j += 1; // 将 j 向右移动一位
    }
    ar[i] = tem; // 将枢轴元素放到它最终的位置上
    return i;
}
// 单边划分的思路是将数组分为两部分，左半部分的元素都小于枢轴元素，右半部分的元素都大于枢轴元素
void QuickSort__(int* ar, int left, int right)//递归
{
    assert(nullptr != ar); // 断言确保指针不为空 
    if (left >= right) return; // 如果 left 大于等于 right，说明数组已经有序，直接返回
    int mid = Parition_one(ar, left, right); // 将数组分成两部分，并返回枢轴的位置
    QuickSort__(ar, left, mid - 1); // 递归排序左半部分
    QuickSort__(ar, mid + 1, right); // 递归排序右半部分
}

2.从两侧向中间遍历（双边划分）

 int ar[22，12，35，42，29，10，55，16，49，78]; 

图解一次快排过程 

 根据该思想流程，得出双边划分单次算法代码：

// 单次算法
int Parition_(int* ar, int left, int right) // 从两边到中间
{
    assert(nullptr != ar); // 断言确保指针不为空
    int tem = ar[left]; // 将最左边的元素作为分界值
    int i = left;  // 从左往右扫描的指针
    int j = right; // 从右往左扫描的指针
    while (i < j)
    {
        // 找到右边第一个比枢轴小的元素
        while (ar[j] > tem && j > i) j--;
        ar[i] = ar[j]; // 将该元素移动到左边
        // 找到左边第一个比枢轴大的元素
        while (ar[i] <= tem && j > i) i++;
        ar[j] = ar[i]; // 将该元素移动到右边
    }
    ar[i] = tem; // 分界值归位
    return i; // 返回分界值的位置
}

  (3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

  (4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了.

#include <stdio.h>
#include <assert.h>
// 单次算法
int Parition_(int* ar, int left, int right) // 从两边到中间
{
    assert(nullptr != ar); // 断言确保指针不为空
    int tem = ar[left]; // 将最左边的元素作为分界值
    int i = left;  // 从左往右扫描的指针
    int j = right; // 从右往左扫描的指针
    while (i < j)
    {
        // 找到右边第一个比枢轴小的元素
        while (ar[j] > tem && j > i) j--;
        ar[i] = ar[j]; // 将该元素移动到左边
        // 找到左边第一个比枢轴大的元素
        while (ar[i] <= tem && j > i) i++;
        ar[j] = ar[i]; // 将该元素移动到右边
    }
    ar[i] = tem; // 分界值归位
    return i; // 返回枢轴的位置
}

// 递归形式的快速排序
void QuickSort_(int* ar, int left, int right)
{
    assert(nullptr != ar); // 断言确保指针不为空
    if (left >= right) return; // 如果 left 大于等于 right，说明数组已经有序，直接返回
    int mid = Parition_(ar, left, right); // 将数组分成两部分，并返回枢轴的位置
    QuickSort_(ar, left, mid - 1); // 递归排序左半部分
    QuickSort_(ar, mid + 1, right); // 递归排序右半部分
}
int main()
{
    const int n=10;
    int ar[n];
    int ar[] = { 56,12,90,89,23,34,45,78,67,100, 47,81,102};
    int len = sizeof(ar) / sizeof(ar[0]); 
    QuickSort__(ar,0,len-1);
    print(ar, len);
    return 0;
}

随机划分： 随机选一个下边的值作为划分依据

// 单次算法
int Parition_(int* ar, int left, int right) // 从两边到中间
{
    assert(nullptr != ar); // 断言确保指针不为空
    int tem = ar[left]; // 将最左边的元素作为分界值
    int i = left;  // 从左往右扫描的指针
    int j = right; // 从右往左扫描的指针
    while (i < j)
    {
        // 找到右边第一个比枢轴小的元素
        while (ar[j] > tem && j > i) j--;
        ar[i] = ar[j]; // 将该元素移动到左边
        // 找到左边第一个比枢轴大的元素
        while (ar[i] <= tem && j > i) i++;
        ar[j] = ar[i]; // 将该元素移动到右边
    }
    ar[i] = tem; // 分界值归位
    return i; // 返回枢轴的位置
}
//随机划分
int Randpation(int* ar, int left, int right)
{
        int rpos = rand() % (right - left + 1) + left;
        std::swap(ar[left], ar[rpos]);
        return Parition_(ar, left, right);
}
void Sort(int* ar, int left, int right)
{
    if (left < right)
    {
        int pos = Randpation(ar, left, right);
        Sort(ar, left, pos - 1);
        Sort(ar, pos + 1, right);
    }
}
void QuickSort(int* ar, int n)
{
    if (nullptr == ar || n < 2) {
        return;
    }
    Sort(ar, 0, n - 1);
}

三位取中法 ：选中位数作为划分依据

// 单次算法
int Parition_(int* ar, int left, int right) // 从两边到中间
{
    assert(nullptr != ar); // 断言确保指针不为空
    int tem = ar[left]; // 将最左边的元素作为分界值
    int i = left;  // 从左往右扫描的指针
    int j = right; // 从右往左扫描的指针
    while (i < j)
    {
        // 找到右边第一个比枢轴小的元素
        while (ar[j] > tem && j > i) j--;
        ar[i] = ar[j]; // 将该元素移动到左边
        // 找到左边第一个比枢轴大的元素
        while (ar[i] <= tem && j > i) i++;
        ar[j] = ar[i]; // 将该元素移动到右边
    }
    ar[i] = tem; // 分界值归位
    return i; // 返回枢轴的位置
}
void solve(int* ar, int left, int right, int mid)
{
    if ((ar[mid]<ar[left] && ar[mid]>ar[right]) || (ar[mid]<ar[right] && ar[mid]>ar[left]))
    {
        std::swap(ar[left], ar[mid]);
    }
    else if ((ar[right]<ar[left] && ar[right]>ar[mid]) || (ar[right]<ar[mid] && ar[right]>ar[left]))
    {
        std::swap(ar[left], ar[right]);
    }
}
void Th_MidSort(int* ar, int left, int right)
{
    if (left < right)
    {
        int mid = (right - left) / 2 + left;
        solve(ar, left, right, mid);
        int pos = Parition_(ar, left, right);
        Th_MidSort(ar, left, pos - 1);
        Th_MidSort(ar, pos + 1, right);
    }
}
void QuickSort(int* ar, int n)
{
    if (nullptr == ar || n < 2) {
        return;
    }
    Th_MidSort(ar, 0, n - 1);
}

该算法的在完全有序的数组下时间复杂度也为为O(nlog n);