O(n^2)排序算法

基础
编码简单，易于实现，是一些简单情景的首选
插入排序是O(n^2)排序算法效率最好的排序算法

1. 速度允许:汇编
2. 特殊情况下,简单排序算法更有效
3. 通过简单排序算法的思想衍生出复杂的排序算法:插入排序->希尔排序
4. 作为子过程,改进更复杂的排序算法

选择排序

8 6 2 3 1 5 7 4

• 8 6 2 3 1 5 7 4
• 1 6 2 3 8 5 7 4
• 1 2 6 3 8 5 7 4
• 1 2 3 6 8 5 7 4
• 1 2 3 4 6 8 5 7
• 1 2 3 4 5 6 8 7
• 1 2 3 4 5 6 7 8

template <typename  T>
void selectionSort( T arr[], int n ){
    for(int i = 0; i < n;i ++){
        int minIndex = i;
        for(int j = i + 1;j < n; j ++){
            if(arr[j] < arr[minIndex]){
                minIndex = j;
            }
        }
        swap(arr[i],arr[minIndex]);
    }
}

插入排序

8 6 2 3 1 5 7 4

• 8 6 2 3 1 5 7 4
• 6 8 2 3 1 5 7 4
• 6 2 8 3 1 5 7 4
• 2 6 8 3 1 5 7 4
• 2 6 3 8 1 5 7 4
• 2 3 6 8 1 5 7 4
• 2 3 6 1 8 5 7 4
• 2 3 1 6 8 5 7 4
• 2 1 3 6 8 5 7 4
• 1 2 3 6 8 5 7 4
• 1 2 3 6 5 8 7 4
• 1 2 3 5 6 8 7 4
• 1 2 3 5 6 7 8 4
• 1 2 3 5 6 7 4 8
• 1 2 3 5 6 4 7 8
• 1 2 3 5 4 6 7 8
• 1 2 3 4 5 6 7 8

从第二个元素开始,当前元素与前一个位置元素相比较

template <typename T>
void insertionSort(T arr[], int n){
    for(int i = 1;i < n;i ++){
        for(int j = i; j > 0;j --){
            if(arr[j] < arr[j - 1]){
                swap(arr[j],arr[j - 1]);
            }else{
                break;
            }
        }
    }
}
//或
template <typename T>
void insertionSort(T arr[], int n){
    for(int i = 1;i < n;i ++){
        for(int j = i; j > 0 && arr[j] < arr[j - 1] ; j--){
            swap(arr[j], arr[j - 1]);
        }
    }
}

插入排序这种方式实现性能比选择排序要差

插入排序的改进

改进为每次只交换一次

template <typename T>
void insertionSort(T arr[], int n){
    for(int i = 1;i < n;i ++){
        //寻找元素arr[i]合适的插入位置
        T e = arr[i];
        //保存元素e应该插入的位置
        int j;
        for( j = i; j > 0 && arr[j] < arr[j - 1] ; j--){
            arr[j] = arr[j - 1];

        }
        arr[j] = e;
    }
}

插入排序对于近乎有序的数据排序效率甚至高于一些O(nlogn)的排序算法,近乎O(n)