[算法]排序算法综述

排序算法有很多种，本文主要介绍基本的排序算法和实现，并分析复杂度和稳定性。

一、Ο(n²)的算法

　　1、插入排序

　　插入排序十分好理解，在无序的数组中选择一个数值，插入到有序的数组当中，这个过程是稳定的。实现代码如下：

　　

template <typename T>
void InsertionSort(vector<T> &arr){
    int i, j;
    for (i = 1; i < arr.size(); i++) {
        int temp = arr[i];
        for (j = i - 1; j >= 0 && arr[j] > temp; j--)
            arr[j + 1] = arr[j];
        arr[j + 1] = temp;
    }

　　2、冒泡排序

　　冒泡排序的过程是遍历数组，每次选取一个数值往前比较，大于前一个数值就交换，直到遇到更大的数值或遍历完数组，这个过程本身也是稳定的。

template <typename T>
void BubbleSort(vector<T> &arr){
    for (int i = 0; i != arr.size(); i++){
        for (size_t j = 0; j < arr.size()-1-i ; j++)
        {
            if (arr[j] > arr[j + 1]){
                arr[j] = arr[j] ^ arr[j+1];
                arr[j+1] = arr[j] ^ arr[j+1];
                arr[j] = arr[j+1] ^ arr[j];
            }
        }
    }
}

 

二、Ο(nlogn)的算法

　　1、归并排序

　　　　归并排序是典型的分治算法，把原问题划分为不相交的子问题。代码如下:

　　　　

void Merge(vector<int> &arr,int l,int m,int r){
    vector<int> Left, Right;
    int n1 = m - l; int n2 = r - m;
    for (int i = 0; i <= n1 ; i++)
        Left.push_back(arr[l + i]);
    Left.push_back(infinite);//哨兵值
    for (int i = 0; i != n2; i++)
        Right.push_back(arr[m + i + 1]);
    Right.push_back(infinite);
    int index1 = 0;int index2 = 0;
    for (int i = l; i != r + 1; i++){
        if (Left[index1] < Right[index2])
            arr[i] = Left[index1++];
        else
            arr[i] = Right[index2++];
    }
};


void MergeSort(vector<int> &arr, int l, int r){
    
    if (l < r){
        int m = int((l + r) / 2);
        MergeSort(arr, l, m);
        MergeSort(arr, m + 1, r);
        Merge(arr, l, m, r);
    }
}

　　2、堆排序

　　　　堆排的本质就是维护一个最大堆（最小堆），所以他的时间复杂度是与最大堆的性质相联系的，一个最大堆的Deletemax操作是O(1)的，而每次DeleteMax后要维护最大堆的性质，所以维护堆的时间复杂度是O(logn)的，合起来就是O(nlogn)。代码实现与建堆类似，就不赘述。

　　　　

　　3、快速排序

　　　　快排也是分治的思想，选取一个主元，将数组分为两个部分，一个部分小于它另一个部分大于它，然后递归两个子数组直到排序完成。快排和主元的选取有关，如果选取的　　      结果恰好是排好序的，那么时间复杂度将会变成O(n²)。

　　　　代码如下：

　　　　

int Partition(vector<int> &arr, int left, int right){
    int i = left - 1;
    for (int j = left; j < right; j++){
        if (arr[j] <= arr[right])
            std::swap(arr[++i], arr[j]);
    }
    std::swap(arr[i + 1], arr[right]);
    return i + 1;
}
void QuickSort(vector<int> &arr,int left,int right){
    if (left < right){
        int mid = Partition(arr, left, right);
        QuickSort(arr, left, mid-1);
        QuickSort(arr, mid+1, right);
    }

}

三、线性算法(以后介绍）

　　

　　1、基数排序

　　2、计数排序

　　3、桶排序