常见的排序算法总结

void BubbleSort(int* array, size_t len)
{
    for (size_t i = 0; i < len; i++)
    {
        for (size_t j = i; j < len - i -1; j++)
        {
            if(array[j] > array[j + 1])
            {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

int main()
{
    int array[] = {3, 1, 5, 2, 7, 9};
    BubbleSort(array, 6);
    for (size_t i = 0; i < 6; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

void BubbleSort(int* array, size_t len)
{
    bool flag = true;
    for (size_t i = 0; i < len && flag; i++)
    {
        flag = false;
        for (size_t j = len - 1; j > i; j--)
        {
            if(array[j-1] > array[j])
            {
                int temp = array[j-1];
                array[j-1] = array[j];
                array[j] = temp;
                flag = true;
            }
        }
    }
}

int main()
{
    int array[] = {3, 1, 5, 2, 7, 9};
    BubbleSort(array, 6);
    for (size_t i = 0; i < 6; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

完整版，避免了只有已经有序的情况下，算法仍然执行。参考大话数据结构382页。

简单选择排序：

void SelectSort(int* array, size_t len)
{
    size_t min;
    for (size_t i = 0; i < len; i++)
    {
        min = i;
        for (size_t j = i + 1; j < len - 1; j++)
        {
            if(array[min] > array[j])
            {
                min = j;
            }
        }
        if(i != min)
        {
            int temp = array[min];
            array[min] = array[i];
            array[i] = temp;
        }
    }
    
}

int main()
{
    int array[] = {3, 1, 5, 2, 7, 9};
    SelectSort(array, 6);
    for (size_t i = 0; i < 6; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

算法思想：

直接插入排序：

希尔排序：

#include <iostream>
using namespace std;
void ShellSort(int* array, int len)
{
    int i, j;
    int increment = len;
    do
    {
        increment = increment / 3 + 1;
        for(i = increment + 1; i < len; i++)
        {
            if(array[i - increment] > array[i])
            {
                array[0] = array[i];
                for(j = i - increment; j > 0 && array[0] < array[j]; j -= increment)
                {
                    array[j + increment] = array[j];
                }
                array[j + increment] = array[0];
                // array[i] = array[i - increment];
                // array[i - increment] = array[0]; 
            }
        }
    } while (increment > 1);
}
int main()
{
    int array[] = {0, 3, 1, 5, 2, 7, 9, 5, 7, 10};
    ShellSort(array, 9);
    for (size_t i = 0; i < 10; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

参考资料，大话数据结构：392

堆排序：

#include <iostream>
using namespace std;

void HeapAdjust(int* array, int index, int length)
{
    int j = index * 2 + 1, tmp = array[index];
    for(; j < length; j = 2 * j + 1)
    {
        if(j + 1 < length && array[j] < array[j + 1])
        {
            j++;
        }
        if(tmp < array[j])
        {
            array[index] = array[j];
        }
        else
        {
            break;
        }
        index = j;
    }
    array[index] = tmp;
}

void HeapSort(int* array, int length)
{
    for(int i = length / 2 - 1; i >= 0; i--)
    {
        HeapAdjust(array, i, length);
    }

    for(int i = length - 1; i > 0; i--)
    {
        int tmp = array[0];
        array[0] = array[i];
        array[i] = tmp;
        HeapAdjust(array, 0, i);
    }

}

int main()
{
    int array[] = {1, 5, 2, 7, 4, 9};
    HeapSort(array, 6);
    for(int i = 0; i < 6; i++)
    {   
        cout << array[i] << " ";
    }
}

归并排序：

#include <iostream>
using namespace std;
#define MAXSIZE 10

void Merge(int* SR, int* TR, int i, int m, int n)
{
    int j, k,l;
    for(j = m + 1, k = i; i <= m && j <= n; k++)
    {
        if(SR[i] < SR[j])
        {
            TR[k] = SR[i++];
        }
        else
        {
            TR[k] = SR[j++];
        }
    }
    if(i <= m)
    {
        for(l = 0; l <= m - i;)
        {
            TR[k++] = SR[i++];
        }
    }
    if(j <= n)
    {
        for(l = 0; l <= n - j;)
        {
            TR[k++] = SR[j++];
        }
    }
}
void MSort(int* SR, int* TR1, int s, int t)
{
    int m;
    int TR2[10];
    if(s == t)
    {
        TR1[s] = SR[s];
    }
    else
    {
        m = (s + t) / 2;
        MSort(SR, TR2, s, m); 
        MSort(SR, TR2, m+1, t);
        Merge(TR2, TR1, s, m, t);
    }
}

void MergeSort(int* array, int len)
{
    MSort(array, array, 0, len - 1);
}

int main()
{
    int array[] = {0, 3, 1, 5, 2, 7, 9, 5, 7, 10};
    MergeSort(array, 10);
    for (size_t i = 0; i < 10; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

参考资料：大话数据结构：411

非递归：待实现 大话数据结构：416

快速排序：

#include <iostream>
using namespace std;
#define MAXSIZE 10

int Partition(int* array, int low, int high)
{
    int pivotkey;
    pivotkey = array[low];
    while(low < high)
    {
        while(low < high && array[high] >= pivotkey)
        {
            high--;
        }
        array[low] = array[high];
        while(low < high && array[low] <= pivotkey)
        {
            low++;
        }
        array[high] = array[low];
    }
    array[low] = pivotkey;
    return low;
}
void QSort(int* array, int low, int high)
{
    int pivot;
    if(low < high)
    {
        pivot = Partition(array, low, high);
        QSort(array, low, pivot - 1);
        QSort(array, pivot + 1, high);
    }
}

void QuickSort(int* array, int len)
{
    QSort(array, 0, len - 1);
}

int main()
{
    int array[] = {0, 3, 1, 5, 2, 7, 9, 5, 7, 10};
    QuickSort(array, 10);
    for (size_t i = 0; i < 10; i++)
    {
        cout << array[i] << " ";
    }
    cout << endl;
}

参考资料：大话数据结构419
https://blog.csdn.net/nrsc272420199/article/details/82587933