排序--冒泡、选择、插入

三种简单排序

1、冒泡排序

时间复杂度 O(n²)
空间复杂度 O(1)

冒泡排序的基本思想是通过比较两个相邻的记录之间的比较和交换，使关键码比较小的继续逐渐从底部移向顶部（上升），关键码比较大的逐渐从顶部移向底部（沉底），冒泡由此得名。

算法思想：

设有A[1]~A[n]的n个数据，冒泡排序的过程可以描述为：
1、首先将相邻的A[1]和A[2]进行比较，如果A[1]的值大于A[2]的值，则交换两者的位置，使得较小的数上浮，较大的数下沉；接着比较A[2]和A[3]，同样使较小的上浮，较大的下沉。依次类推，直到比较完A[n-1]和A[n]后，A[n]为具有最大关键码的元素，称为第一趟排序结束。
2、然后再A[1]~A[n-1]区间内，进行第二趟排序，使剩余元素中关键码最大的元素下沉到A[n-1]。重复进行n-1趟后，整个排序过程结束。

void BubbleSort(int array[],int num)
{
    int i,j,temp;
    for(j = 0;j < num-1;j++)               //进行num-1次排序
        for(i = 0;i < num-j-1;i++)         //每次比较num-j-1次
            if(array[i] > array[i+1])
            {
                    temp = array[i];
                array[i] = array[i+1];
                array[i+1] = temp;  
            }
}

2、选择排序

时间复杂度 O(n²)
空间复杂度 O(1)

选择排序的基本思想是第i趟排序通过n-i次关键码的比较，从n-i+1个记录中选出关键码最小的记录，并和第i个记录进行交换。

算法思想：

设有A[1]~A[n]的n个数据，选择排序的过程可以描述为：
1、首先在A[1]~A[n]区间内进行比较，从n个记录中选择最小的记录A[k]，若k不为1则将A[1]和A[k]交换，A[1]为具有最小关键码的元素，成为第一趟排序结束。
2、然后再A[i]~A[n]区间内，进行第i趟排序，从n-i+1个记录中选出最小的记录A[k]，若k不为i则将A[i]和A[k]交换。重复进行n-1趟后，整个排序过程结束。

void SelectionSort(int array[],int num)
{
    int i,j,k,temp;
    for(j = 0;j < num-1;j++)         //进行num-1次排序
    {
        //从array[j]到array[num],寻找最小的数，并用k记录
        k = j;
        for(i = j+1;i < num;i++)     
            if(array[i] < array[k]) k = i;

        if(j != k)
            {
                temp = array[j];
                array[j] = array[k];
                array[k] = temp
            }      
    }       
}

3、插入排序

时间复杂度 O(n²)
空间复杂度 O(1)

插入排序的基本思想是把新插入记录的关键码与已经排好序的各记录关键逐个比较(这里从后往前比较，也可以从前往后)，当找到第一个比新纪录关键码小的记录时，该记录之后即为插入位置k。然后从序列最后一个记录开始到该记录之后的一个元素，逐个后移一个单元，将新记录插入k位置。如果新纪录的关键码比序列中所有的记录都大，则插入到最后的位置。

算法思想：

设有A[1]~A[n]的n个数据，插入排序的过程可以描述为：
1、已排好序列首先为A[1]。
2、然后将A[2]~A[n]逐个插入序列中，进行第i趟排序。将A[i]与A[1]~A[i-1]关键码进行比较，若找到A[k]比A[i]大，则A[k]~A[i-1]逐个后移一个单元，将A[i]插入到k位置；若A[i]比所有的元素都大，则什么也不做。重复进行n-1趟排序后，整个排序过程结束。

void InsertionSort(int array[],int num)
{
    int i,k,temp;
    for(i = 1;i < num;i++)     //进行num次排序,起始序列为A[0]
    {
        temp = array[i];
        k = i-1;
        while(temp < array[k])
        {
            A[k+1] = A[k];
            k--;
            if(k == -1)break;
        }
        A[k+1] = temp;
    }       
}

最后附上排序算法的稳定性比较，图片来自网络：