讲讲排序(C++描述 )

排序和查找一直是算法的主流问题。
排序方法有很多种：
1.简单排序(O(n^2))

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

void SimpleSort(int *a,int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if (a[i] > a[j]) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;    
            } 
        }
    }
}

int main(){
    int a[20],n;
    cin >> n;
    for (int i = 0; i < n && i < 20; ++i) {
        cin >> a[i];
    }
    SimpleSort(a,min(n,20));

    for (int i = 0; i < n && i < 20; ++i) {
        cout << a[i]<<" ";
    }
    cout << endl;
} 

简单排序是实现就上面这些。（看起来很上的那一堆，主要是用了方便检验）至于调用了min,所以才会有那个include 那个algorithm,对了,稍微懂点的，或者还没有忘掉的哥们，应该还是很清楚这个库里面就包含了sort函数，这个就是用快排实现的。

2.冒泡排序 O（n^ 2）运气好可以是O(n)

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

void BubbleSort(int *a,int n){
    for (int j = 0; j < n - 1; ++j) {
        for (int i = 0; i < n - 1 - j; ++i) {
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
            }
        }
    }
}

int main(){
    int a[20],n;
    cin >> n;
    for (int i = 0; i < n && i < 20; ++i) {
        cin >> a[i];
    }
    BubbleSort(a,min(n,20));

    for (int i = 0; i < n && i < 20; ++i) {
        cout << a[i]<<" ";
    }
    cout << endl;
}

也不难理解，就是将每一个大小顺序的点排到一个排的地方去，第一次是排最大的那个。依次类推。
由于前两个比较可以使得在a[1]放的是a[0] a[1]中比较大的那个。
再来就是就是a[2]放的是a[1] a[2]中比较大的那个。由于a[1]又是a[0] a[1]中最大的那个，也就确保了a[2]是前三个中最大的那个。依次类推，排完所有点。

冒泡还有种写法

void BubbleSort(int *arr, int n){
    bool change; 
    for (int i = n-1, change = true; change && i > 0; --i) {
        change = false;
        for (int j=0; j < i; ++j) {
            if (arr[i] < arr[j]) {
                change = true;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            } 
        }
    }
}

3.归并排序（MergeSort）

#include <iostream>
#define SIZE 100
//设置最大长度 
using namespace std;
void MergeSort(int *a ,int s,int e){
    if (s >= e || s < 0 || e < 0)
        return;
    int mid = (s + e) / 2;
    MergeSort(a,s,mid);
    MergeSort(a,mid + 1,e);
    int i,j;
    i = s;
    j = mid + 1;
    int b[SIZE],tot = 0; 

    while (i <= mid&& j <= e) {
        if (a[i] > a[j]) {
            b[tot++] = a[j++]; 
        } else {
            b[tot++] = a[i++];
        }
    }
    while (i <= mid) {
        b[tot++] = a[i++];
    } 
    while (j <= e) {
        b[tot++] = a[j++];
    }
    for (int i = 0; i < tot; ++i) {
        a[s + i] = b[i];
    }
}

int main(){
    int a[20],n;
    cin >> n;
    for (int i = 0; i < n && i < 20; ++i) {
        cin >> a[i];
    }

    MergeSort(a,0,n - 1);

    for (int i = 0; i < n && i < 20; ++i) {
        cout << a[i]<<" ";
    }
    cout << endl;
}

4.选择排序
把最小的放最前面，或者是反过来也是可以的。

#include <iostream>
using namespace std;

void SelectSort(int *a,int n) {
    for (int i = 0; i < n - 1; ++i) {
        int min = i;
        for (int j = i + 1; j < n; ++j) 
            if (a[j] < a[min]) {
                min = j;
            }
        if (min != i) {
            int temp = a[i];
            a[i] = a[min];
            a[min] = temp;
        }
    }
}

int main() {
    int a[20],n;
    cin >> n;
    for (int i = 0; i < n && i < 20; ++i) {
        cin >> a[i];
    }

    SelectSort(a,n);

    for (int i = 0; i < n && i < 20; ++i) {
        cout << a[i]<<" ";
    }
    cout << endl;
}

5.快速排序

#include <iostream>
using namespace std;

void sort (int *a,int s,int e){
    if (s >= e)
        return;
    int i = s,j = e,k = a[s];
    while (i < j) {
        while ( i < j && a[j] >= k)
            --j;
        if ( i < j ) {
            a[i] = a[j];
        }
        while ( i < j && a[i] <= k)
            ++i;
        if ( i < j ) {
            a[j] = a[i];
        }
    }
    a[i] = k;
    sort(a,s,i-1);
    sort(a,i+1,e);
}

int main(){
    int a[1000];
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    sort(a,0,n-1);
    for (int i = 0; i < n; ++i) {
        cout << a[i]<<" ";
    } 
    cout << endl;
}

还有一种写法：

void QSort(int *arr, int begin, int end) {
    if (begin >= end) return;
    // 枢轴元素就需求最前里面的那个
    int i = begin, j = end, key = arr[begin]; // 坑在begin点 
    while (i < j) {
        while (i < j && arr[j] >= key) --j;
        if (i < j) arr[i] = arr[j];
        while (i < j && arr[i] <= key) ++i;
        if (i < j) arr[j] = arr[i]; 
    } 
    arr[i] = key;
    QSort(arr, begin, i -1);
    QSort(arr, i + 1, end);
}

6.插入排序

//非降序 
void insertionSort(int* s, int n) {
    for (int i = 1; i < n; ++i) {
        //s[0]默认排好了
        int key = s[i];//记录key值
        int j = i - 1;  
        while (j >= 0 && s[j] > key) // 移动到最顶端或小于等于的key 
            s[j + 1] = s[j--];
        s[j + 1] = key;
    }
}

7.堆排序

#include <iostream>
using namespace std;

int *a, size; // a是一个数组，size是我们设置那个堆的大小，不是数组的大小
void max_Heapify(int i){ // 假设左右堆都是最大堆了 
    int l = 2*i + 1; // 得到左子树 
    int r = 2*i + 2, largest = i; // 得到右子树 
    if (l < size && a[l] > a[largest])
        largest = l;
    if (r < size && a[r] > a[largest]) 
        largest = r;
    if (largest != i) {
        int temp = a[i];
        a[i] = a[largest];
        a[largest] = temp; // 交换父节点和两个最大堆的根节点 
        max_Heapify(largest);
    }
} // 用于维护最大堆
void build_max_Heapify(){ // 相当于从最后一层开始建堆 
    for(int i = size / 2 - 1; i >= 0;--i){
        max_Heapify(i);
    }
}
void HeapSort(){
    build_max_Heapify(); // 构建最大堆 
    for (int i = size-1; i > 0; --i) { 
        int temp = a[i];
        a[i] = a[0];
        a[0] = temp;
        size -= 1;
        max_Heapify(0); 
    } 
}

总体来说，我还是比较喜欢快排的。这是用递归实现的，如果能转成用栈去模拟栈的话，应该会降低时间复杂度。
桶排会更快，但是我目前掌握的话，这个还是有点缺陷的。我现在用桶排只能处理自然数的排序….
最后，给我的公众号拉一波关注！
本人中大一肥宅，欢迎大家关注，请扫下面的二维码