八大排序算法

1，冒泡排序

void BubbleSort(int *array,int length) {
    bool flag;//标志位 
    for(int i = length - 2;i >= 0;--i) {
        flag = true;
        for(int j = 0;j <= i;++j) {
            if(array[j] > array[j+1]) {
                flag = false;//此趟发生了交换 
                swap(&array[j],&array[j+1]);
            }
        }
        if(flag == true)//某一趟没发生交换，说明已经排序好 
        break;
    }
}

 算法说明：

1，每次挑出最大的元素放到数组最后的位置。

2，一次性把元素放到最终位置。

3，某一趟没发生交换，说明数组已经完全有序，提前结束排序。

时间复杂度：

最坏（n^2）：极其无序

最好（n）：数组已经有序，扫描一遍数组而已。

平均（n^2）

稳定性：稳定

适用：大致有序的小数据量。

2，选择排序

void SelectSort(int *array,int length) {
    int minIndex;//保存最小元素的下标 
    for(int i = 0;i < length;++i) {
        minIndex = i;//当前一趟的第一个元素的下标 
        for(int j = i;j < length;++j) {
            if(array[j] < array[minIndex])
            minIndex = j;//更新minIndex 
        }
        swap(&array[minIndex],&array[i]);
    }
}

1，每趟挑出一个最小的放到最终位置

2，无论数组原始情况，都要彻底扫描数组

3，稳定性：稳定的

4，相比冒泡排序的优点是，保存索引但不交换，开销小。缺点是冒泡排序可以提前结束。

5，时间复杂度：最好，最坏，平均都是n^2

6，最适：数组初始顺序无所谓。小数据量。

3，直接插入排序

void InsertSort(int *array,int length) {
    int temp;//暂存待排序的元素 
    int j;
    for(int i = 1;i < length;++i) {
        temp = array[i];
        for(j = i - 1;j >= 0 && array[j] > temp;--j)
            array[j+1] = array[j];
        array[j+1] = temp;
    }
}

1，从第二个元素起，与它前面的所有元素比较，找到它应该插入的位置，插入之。

2，非一次性放入最终位置

3，时间复杂度：最好n 最差和平均n^2

4，最适：越有序越好，小数据量。

5，稳定的

4，快速排序

5，归并排序