常见排序算法

#include<iostream>
using namespace std;

//打印数组
void printArray(int A[], int N)
{
    for(int i=0;i<N;i++)
        cout << A[i] << " ";
}

//交换两值
void Swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

//插入排序
void InsertSort(int A[], int N)
{
    int i, j;
    for(i=1;i<N;i++)
        if (A[i] < A[i - 1])
        {
            int tmp = A[i];
            for (j = i; j > 0 && tmp < A[j]; j--)
                A[j] = A[j - 1];
            A[j] = tmp;
        }
}

//希尔排序
void ShellSort(int A[], int N)
{
    int i, j, Increment;
    int tmp;
    for(Increment=N/2;Increment>0;Increment/=2)
        for (i = Increment; i < N; i++)
        {
            tmp = A[i];
            for (j = i; j >= Increment&&tmp < A[j - Increment]; j -= Increment)
                A[j] = A[j - Increment];
            A[j] = tmp;
        }
}



//直接选择排序
void SelectSort(int A[], int N)
{
    int i, j, min;
    for (int i = 0; i < N - 1; i++)
    {
        min = i;
        for (j = i + 1; j < N; j++)
            if (A[j] < A[min])
                min = j;
        Swap(A[i], A[min]);
    }
}

//调整堆    最大堆
void HeapAdjusting(int A[], int root, int N)
{
    int tmp = A[root];
    int child = 2 * root + 1;    //左孩子
    while (child < N)
    {
        //找孩子节点中较大的那个
        if (child + 1 < N&&A[child + 1] > A[child])
            child++;
        //如果较大的孩子节点大于父节点，用较大的子节点替换父节点，并重新设置下一个需要调整的父节点和子节点
        if (A[root] < A[child])
        {
            A[root] = A[child];
            root = child;
            child = 2 * root + 1;
        }
        else
            break;
        //调整父节点的值赋给调整后的位置
        A[root] = tmp;
    }
}

//初始化堆
void HeapBuilding(int A[], int N)
{
    //从最后一个有孩子节点的位置开始调整，最后一个有孩子节点的位置为（n-1）/2
    for (int i = (N - 1) / 2; i >= 0; i--)
        HeapAdjusting(A, i, N);
}

//堆排序
void HeapSort(int A[], int N)
{
    //初始化堆
    HeapBuilding(A, N);
    //从最后一个节点开始调整
    for (int i = N - 1; i > 0; i--)
    {
        //交换堆顶元素和最后一个元素
        Swap(A[0], A[i]);
        //每次交换后都要进行调整
        HeapAdjusting(A, 0, i);
    }
}

//冒泡排序
void BubbleSort(int A[], int N)
{
    int i, j;
    for (i = 0; i < N - 1; i++)
        for (j = 0; j < N - i - 1; j++)
            if (A[j] > A[j + 1])
                Swap(A[j], A[j + 1]);
}

//选主元
int Median3(int A[], int Left, int Right)
{
    int Center = (Left + Right) / 2;
    if (A[Left] > A[Center])
        Swap(A[Left], A[Right]);
    if (A[Left] > A[Right])
        Swap(A[Left], A[Right]);
    if (A[Center] > A[Right])
        Swap(A[Center], A[Right]);

    Swap(A[Center], A[Right - 1]);

    return A[Right - 1];
}

#define Cutoff 3

void QSort(int A[], int Left, int Right)
{
    int i, j;
    int Pivot;

    if (Left + Cutoff <= Right)
    {
        Pivot = Median3(A, Left, Right);
        i = Left; j = Right - 1;
        for (;;)
        {
            while (A[++i] < Pivot) {}
            while (A[--j] < Pivot) {}
            if (i < j)
                Swap(A[i], A[j]);
            else
                break;
        }
        Swap(A[i], A[Right - 1]);
        QSort(A, Left, i - 1);
        QSort(A, i + 1, Right);
    }
    else
        InsertSort(A + Left, Right - Left + 1);
}

//快速排序
void QuickSort(int A[], int N)
{
    QSort(A, 0, N - 1);
}

//归并过程
void Merge(int A[], int TmpArray[], int Left, int Right, int RightEnd)
{
    int LeftEnd = Right - 1;
    int Tmp = Left;        //存放临时数组位置
    int NumElements = RightEnd - Left + 1;
    while (Left <= LeftEnd&&Right <= RightEnd)
        if (A[Left] <= A[Right])
            TmpArray[Tmp++] = A[Left++];
        else
            TmpArray[Tmp++] = A[Right++];
    while (Left <= LeftEnd)
        TmpArray[Tmp++] = A[Left++];
    while (Right <= RightEnd)
        TmpArray[Tmp++] = A[Right++];


    for (int i = 0; i < NumElements; i++,RightEnd--)
        A[RightEnd] = TmpArray[RightEnd];
}

//递归过程
void MSort(int A[], int TmpArray[], int Left, int Right)
{
    int Center;
    if (Left < Right)
    {
        Center = (Left + Right) / 2;
        MSort(A, TmpArray, Left, Center);
        MSort(A, TmpArray, Center + 1, Right);
        Merge(A, TmpArray, Left, Center + 1, Right);
    }
}

//归并排序
void MergeSort(int A[], int N)
{
    int *TmpArray;
    TmpArray = (int*)malloc(N*sizeof(int));
    if (TmpArray != NULL)
    {
        MSort(A, TmpArray, 0, N - 1);
        free(TmpArray);
    }
    else
        cout << "Out of space!" << endl;
}

int main()
{
    int A[10]{ 2,1,4,8,6,5,9,7,0,3 };
    printArray(A, 10);
    cout << endl;
    //ShellSort(A, 10);
    //SelectSort(A, 10);
    //HeapSort(A, 10);
    //BubbleSort(A, 10);
    MergeSort(A,  10);
    printArray(A, 10);


    return 0;
}