快速排序，归并排序，三路快排总结

1、快速排序

int partion(int a[], int low, int high)
{
    int pivot = a[low];
    while (low < high)
    {
        while (low < high && a[high] >= pivot) // 注意是大于等于，否则会出现等于pivot的值被循环交换
        {
            high--;
        }
        a[low] = a[high];
        while (low < high && a[low] <= pivot)
        {
            low++;
        }
        a[high] = a[low];
    }
    a[low] = pivot;
    return low;
}
void quicksort(int a[], int low, int high)
{
    if (low < high)
    {
        int mid = partion(a, low, high);
        quicksort(a, low, mid - 1); // 注意是到mid-1，不要再加上mid了
        quicksort(a, mid - 1, high);
    }
}

2、归并排序

void merge(vector<int> &a, int front, int mid, int end)
{
    vector<int> LeftSubArray(a.begin() + front, a.begin() + mid + 1);
    vector<int> RightSubArray(a.begin() + mid + 1, a.begin() + end + 1);
    int idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());
    // Pick min of LeftSubArray[idxLeft] and RightSubArray[idxRight], and put into Array[i]
    for (int i = front; i <= end; i++)
    {
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight])
        {
            a[i] = LeftSubArray[idxLeft];
            idxLeft++;
        }
        else
        {
            a[i] = RightSubArray[idxRight];
            idxRight++;
        }
    }
}
void mergesort(vector<int> &a, int front, int end)
{
    if (front >= end)
    {
        return;
    }
    int mid = (front + end) / 2;
    mergesort(a, front, mid);
    mergesort(a, mid + 1, end);
    merge(a, front, mid, end);
}

参考链接（https://www.runoob.com/w3cnote/merge-sort.html）

3、三路快排

void triquicksrt(int a[], int low, int high)
{
    if (low >= high)
        return; // 必要的判断，合理性
    int pivot = a[low];
    int i = low;
    int l = low;
    int h = high;
    while (i <= h) // 注意是等于，因为h这个位置并没有被判断过
    {
        if (a[i] > pivot)
        {
            swap(a[i], a[h]);
            h--;
        }
        else if (a[i] < pivot)
        {
            swap(a[i++], a[l++]);
        }
        else
        {
            i++;
        }
    }
    triquicksrt(a, low, l);
    triquicksrt(a, h + 1, high);
    // 因为上面判断是小于等于，h指向的是大于pivot那一部分的再后面的一位
}