排序算法总结

冒泡排序：

#include "Bubble_Sort.h"

void bubble_sort01(int array[], int length)
{
    for (int i = 1; i < length; i++)
    {
        for (int j = 1; j < length - i; j++)//大数沉底
        {
            if (array[j] < array[j - 1])
            {
                swap(array[j], array[j - 1]);
            }
        }
    }
}

void bubble_sort02(int array[], int length)
{
    bool flag = true;
    while (flag)//如果有一趟没有发生交换，说明排序已经完成
    {
        flag = false;
        for (int i = 1; i < length; i++)//大数沉底
        {
            if (array[i] < array[i - 1])
            {
                swap(array[i], array[i - 1]);
                flag = true;//这一趟发生了交换，则为true，否则为false
            }
        }
    }
}

void bubble_sort03(int array[], int length)
{
    int pos = length;
    int flag;
    while (pos > 0)//
    {
        flag = pos;
        pos = 0;
        for (int i = 1; i < flag; i++)//大数沉底
        {
            if (array[i] < array[i - 1])
            {
                swap(array[i], array[i - 1]);
                pos = i;//记录最后做交换的位置i，i之后的数列必定有序（包含i）
            }
        }
    }
}

插入排序：

#include "Insert_Sort.h"

void insert_sort01(int array[], int length)
{
    int firstNum;//从无序区开始的第一个值
    for (int i = 1; i < length; i++)//保证数组从0至i-1都为有序序列
    {
        if (array[i] < array[i - 1])//若选定数比之前的有序数列最大值大，不需要做调整
        {
            firstNum = array[i];
            int j = i - 1;
            for (; (array[j] > firstNum) && (j >= 0); j--)
            {
                array[j + 1] = array[j];//将比array[i]大的数向后移位1个位置
            }
            array[j + 1] = firstNum;//将array[i]插入到有序序列合适的位置
        }
    }
}

归并排序：

#include "Merge_Sort.h"

const int minUnit = 1;

void mergeData(int array[], int posL, int posR, int* temp)
{
    int mid = (posL + posR) / 2;
    int l = posL;
    int r = mid + 1;
    int k = 0;
    while (mid >= l&&posR >= r)
    {
        if (array[l] < array[r])
        {
            temp[k++] = array[l++];//左右两个序列长度为1时，可确保左右两个序列有序，所以合并序列时可以直接取序列第一个值
        }
        else
        {
            temp[k++] = array[r++];//左右两个序列长度为1时，可确保左右两个序列有序，所以合并序列时可以直接取序列第一个值
        }
    }
    while (l > mid&&posR >= r)//当左序列取尽且右序列还有值时，可直接添加右序列剩下的值可确保合并的序列依然有序
    {
        temp[k++] = array[r++];
    }

    while (r > posR&&mid >= l)//当右序列取尽且左序列还有值时，可直接添加右序列剩下的值可确保合并的序列依然有序
    {
        temp[k++] = array[l++];
    }

    k = 0;
    for (int i = posL; i <= posR; i++)
    {
        array[i] = temp[k++];
    }
}

void mergeAction(int array[], int posL, int posR, int* temp)
{
    if (posR - posL > minUnit)
    {
        mergeAction(array, posL, (posL + posR) / 2, temp);//对左面序列进行排序
        mergeAction(array, (posL + posR) / 2 + 1, posR, temp);//对右面序列进行排序

    }
    mergeData(array, posL, posR, temp);//合并左右两个序列
}

void merge_sort01(int array[], int posL, int posR)
{

    int * temp = new int[posR - posL + 1]();
    mergeAction(array, posL, posR, temp);
    delete[] temp;
}

快速排序：

#include "Quick_Sort.h"

int adjustArray01(int array[], int l, int r)
{
    int i = l, j = r;
    int x = array[i];//基准数的位置，将它设为空缺位

    while (i < j)
    {
        while ((i < j) && (array[j] > x))//从后往前寻找比基准数小的值
        {
            j--;
        }
        if (i < j)
        {
            array[i] = array[j];//将该值赋予之前空缺位的位置，该值原本的位置为新的空缺位位置
            i++;
        }

        while ((i < j) && (array[i] < x))//从前往后寻找比基准数大的值
        {
            i++;
        }
        if (i < j)
        {
            array[j] = array[i];//将该值赋予之前空缺位的位置，该值原本的位置为新的空缺位位置
            j--;
        }
    }//循环结束之后保证基准数之前的值都小于基准数，基准数之后的值都大于基准数
    array[i] = x;
    return i;//i作为递归的左区最大值和右区最小值
}

void quick_sort01(int array[], int l, int r)
{
    if (l < r)
    {
        int i = adjustArray01(array, l, r);
        quick_sort01(array, l, i - 1);//递归调用之后，保证每个基准数（每个数），之前的值都小于基准数，基准数之后的值都大于基准数
        quick_sort01(array, i + 1, r);//递归调用之后，保证每个基准数（每个数），之前的值都小于基准数，基准数之后的值都大于基准数
    }
}

void quick_sort02(int array[], int l, int r)
{
    if (l < r)
    {
        int i = l, j = r;
        int x = array[i];//基准数的位置，将它设为空缺位

        while (i < j)
        {
            while ((i < j) && (array[j] > x))//从后往前寻找比基准数小的值
            {
                j--;
            }
            if (i < j)
            {
                array[i++] = array[j];//将该值赋予之前空缺位的位置，该值原本的位置为新的空缺位位置
            }

            while ((i < j) && (array[i] < x))//从前往后寻找比基准数大的值
            {
                i++;
            }
            if (i < j)
            {
                array[j--] = array[i];//将该值赋予之前空缺位的位置，该值原本的位置为新的空缺位位置
            }
        }//循环结束之后保证基准数之前的值都小于基准数，基准数之后的值都大于基准数
        array[i] = x;
        quick_sort02(array, l, i - 1);//递归调用之后，保证每个基准数（每个数），之前的值都小于基准数，基准数之后的值都大于基准数
        quick_sort02(array, i + 1, r);//递归调用之后，保证每个基准数（每个数），之前的值都小于基准数，基准数之后的值都大于基准数
    }
}

选择排序：

#include "Select_Sort.h"

void select_sort01(int array[], int length)
{
    int minPos;
    for (int i = 0; i < length; i++)
    {
        minPos = i;
        for (int j = i; j < length; j++)
        {
            if (array[minPos] > array[j])
            {
                minPos = j; //获取无序序列最小值的位置
            }
        }
        swap(array[i], array[minPos]);//交换无序序列最小值和有序序列的最后一个值的位置
    }
}

希尔排序：

#include "Shell_Sort.h"

void shell_sort01(int array[], int length)
{
    for (int gap = length / 2; gap > 0; gap /= 2)//分解为gap个组
    {
        for (int i = 0; i < gap; i++)//有多少步长就需要遍历几次
        {
            for (int j = i + gap; j < length; j += gap)//从此处开始插排,i+gap表示从第二个值开始遍历，符合插排，每个元素相隔gap个位置
            {
                int k = j - gap;
                int temp = array[j];
                while (temp < array[k])
                {
                    array[k + gap] = array[k];
                    k -= gap;
                }
                array[k + gap] = temp;
            }
        }
    }
}

void shell_sort02(int array[], int length)
{
    for (int gap = length / 2; gap > 0; gap /= 2)//分解为gap个组
    {
        for (int i = gap; i < length; i++)//每次比较所有组，每次比较所有组，可节省一次遍历
        {
            int k = i - gap;
            int temp = array[i];
            while (temp < array[k])//从此处开始插排,i+gap表示从第二个值开始遍历，符合插排，每个元素相隔gap个位置
            {
                array[k + gap] = array[k];
                k -= gap;
            }
            array[k + gap] = temp;
        }
    }
}