【数据结构基础】五大排序算法的C++实现（冒泡，选择，插入，归并，快排）

（目前只写了这五个，后续的在更）

1. 冒泡排序：

1.1 算法流程：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

1.2 算法图解：

1.3 代码实现：

void BubbleSort(int a[], long size)
{
    // 冒泡排序
    for (long i = 0; i < size; i++)
    {
        bool flag = true;
        for (long j = 0; j < size - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
                flag = false;
            }
        }
        if (flag)
        {
            return;
        }
    }
}

2. 选择排序：

2.1 算法流程：

1. 初始状态：无序区为R[1…n]，有序区为空；
2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3. n-1趟结束，数组有序化了。

2.2 算法图解：

2.3 代码实现：

void SelectSort(int a[], long size)
{
    // 选择排序
    for (long i = 0; i < size; i++)
    {
        int minnum = a[i];
        long index = i;
        for (long j = i; j < size; j++)
        {
            if (a[j] <= minnum)
            {
                minnum = a[j];
                index = j;
            }
        }
        swap(a[index], a[i]);
    }
}

3. 插入排序：

3.1 算法流程：

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

3.2 算法图解：

3.3 代码实现：

void InsertSort(int a[], long size)
{
    // 插入排序
    for (long i = 1; i < size; i++)
    {
        int temp = a[i];
        long j;
        for (j = i - 1; j >= 0; j--)
        {
            if (a[j] > temp)
            {
                a[j + 1] = a[j];
            }
            else
            {
                break;
            }
        }
        a[j + 1] = temp;
    }
}

4. 归并排序：

4.1 算法流程：

1. 把长度为n的输入序列分成两个长度为n/2的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

4.2 算法图解：

4.3 代码实现：

void MergeSort(int a[], long l, long r)
{
    // 归并排序
    if (r - l < 2)
    {
        return;
    }
    long m = (l + r) / 2;
    MergeSort(a, l, m);
    MergeSort(a, m, r);
    Merge(a, l, m, r);
}

void Merge(int a[], long l, long m, long r)
{
    long ml = m - l;
    int *b = new int[ml];
    for (long i = 0; i < ml; i++)
        b[i] = a[l + i];
    long x = 0, y = m;
    for (long i = l; i < r;)
    {
        if ((b[x] <= a[y] && x < ml) || y >= r)
        {
            a[i++] = b[x++];
        }
        if ((a[y] < b[x] && y < r) || x >= ml)
        {
            a[i++] = a[y++];
        }
    }
    delete[] b;
}

5. 快速排序：

5.1 算法流程：

1. 从数列中挑出一个元素，称为 “基准”（pivot）；
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

5.2 算法图解：

5.3 代码实现：

void QuickSort(int a[], int l, int r)
{
    // 快速排序
    if (l < r)
    {
        int i = l, j = r, x = a[l];
        while (i < j)
        {
            while (i < j && a[j] >= x) // 从右向左找第一个小于x的数
            {
                j--;
            }
            if (i < j)
            {
                a[i++] = a[j];
            }
            while (i < j && a[i] < x) // 从左向右找第一个大于等于x的数
            {
                i++;
            }
            if (i < j)
            {
                a[j--] = a[i];
            }
        }
        a[i] = x;
        QuickSort(a, l, i - 1); // 递归调用
        QuickSort(a, i + 1, r);
    }
}