各种排序算法（插入、交换、选择、归并）

#include <iostream>
#include <cstdlib>
using namespace std;

const int N = 10;

/********************** 插入排序 **********************/

// 简单插入排序 O(n2)
void InsertSort(int *a)
{
    int i,j,temp;

    for(i = 1;i < N;i ++)
    {
        temp = a[i];
        j = i - 1;
        while(j >= 0 && a[j] > temp)
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = temp;
    }
}

/********************** 交换排序 **********************/

// 冒泡排序 O(n2)
void BubbleSort(int *a)
{
    int i,j,temp;

    for(i = 0;i < N - 1;i ++)
    {
        for(j = N - 1;j > i;j --)
        {
            if(a[j] > a[j - 1])
            {
                temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

// 快速排序划分函数
int partition(int *a, int left, int right)
{
    int l = left;
    int r = right;
    int key = a[left];

    while(l < r)
    {
        while(l < r && a[r] < key)
            r --;
        a[l] = a[r];

        while(l < r && a[l] > key)
            l ++;
        a[r] = a[l];
    }
    a[l] = key;

    return l;
}

// 快速排序 O(nlogn)
void QuickSort(int *a,int left,int right)
{
    int pivot;
    if(left < right)
    {
        pivot = partition(a,left,right);
        QuickSort(a,pivot + 1,right);
        QuickSort(a,left,pivot - 1);
    }

}

/********************** 选择排序 **********************/

// 简单选择排序 O(n2)
void SelectionSort(int *a)
{
    int i,j,minIndex,temp;

    for(i = 0;i < N - 1;i ++)
    {
        minIndex = i;
        for(j = i;j < N;j ++)
        {
            if(a[minIndex] > a[j])
                minIndex = j;
        }
        if(minIndex != i)
        {
            temp = a[minIndex];
            a[minIndex] = a[i];
            a[i] = temp;
        }
    }
}

// 堆排序调整函数
void sift(int *a, int low, int high)
{
    int i = low;
    int j = 2 * i;

    while(j <= high)
    {
        if(j < high && a[j] > a[j + 1])
            j ++;
        if(a[i] > a[j])
        {
            a[i] = a[i] ^ a[j];
            a[j] = a[i] ^ a[j];
            a[i] = a[i] ^ a[j];
            i = j;
            j = 2 * i;
        }
        else
            break;
    }
}

// 堆排序 O(nlogn)
void HeapSort(int *a ,int low, int high)
{
    int n = high;

    for(int i = n / 2;i >= 1;i--)
        sift(a,i,n);
    for(int i = n;i >= 2;i--)
    {
        int tmp = a[i];
        a[i] = a[1];
        a[1] = tmp;
        sift(a,1,i - 1);
    }
}

/********************** 归并排序 **********************/

// 归并操作
void Merge(int *a, int low, int mid, int high)
{
    int i = low;
    int j = mid + 1;
    int k = 0;
    int *tmp = (int*)malloc((high - low + 1) * sizeof(int));
    while(i <= mid && j <= high)
    {
        if(a[i] > a[j])
            tmp[k++] = a[j++];
        else
            tmp[k++] = a[i++];
    }
    while(i <= mid)
        tmp[k++] = a[i++];
    while(j <= high)
        tmp[k++] = a[j++];
    for(k = 0,i = low;i <= high;i ++,k++)
        a[i] = tmp[k];
    free(tmp);
}

// 归并排序 O(nlogn)
void MergeSort(int *a, int low, int high)
{
    if(low < high)
    {
        int mid = (low + high) / 2;
        MergeSort(a,low,mid);
        MergeSort(a,mid + 1,high);
        Merge(a,low,mid,high);
    }
}

// 输出
void print(int *a)
{
    for(int i = 0;i < N;i ++)
        cout << a[i] << ' ';
    cout << endl;
}

int main()
{
    int a[N] = {2,4,7,1,0,9,8,6,3,5};

    // down
    BubbleSort(a);
    print(a);

    // up
    SelectionSort(a);
    print(a);

    // down
    QuickSort(a,0,N - 1);
    print(a);

    // up
    InsertSort(a);
    print(a);

    // down
    // 堆排序第0 位不用，从a[1] 开始排序
    HeapSort(a,0,N - 1);
    print(a);

    // up
    MergeSort(a,0,N - 1);
    print(a);
    return 0;
}

稳定排序是：插起基归（插入、起泡、基数、归并），可谐音为“插起鸡归”（咳...嗯...）