十大排序算法代码总览(C++)

注：
算法稳定性
定义：待排序序列中的相同关键字记录经过排序后相对次序保持不变。比如Xm=xn,原本Xm在Xn之前，排序后依然Xm在Xn之前。
条件：算法的稳定性由具体算法决定，且在一定条件下算法稳定性也会发生转变。
稳定性意义：只有在排序一个复杂对象的多个数字属性且初始顺序存在意义时，才需要注意算法的稳定性，即需要尽量保持原有排序序列的意义。比如原本商品按价格高低排序，想着想要按销量排序，且使得同销量的商品依然保持价格高低的排序，这是可以使用稳定性算法。

1冒泡排序(Bubble Sort)

简述：

重复进行相邻数组元素的两两比较，并按规则进行交换，直到没有元素再需要交换。最终使得大的元素逐渐沉到数列底部，相较小的元素浮现到数列前端。

算法描述：

1 比较相邻两个元素，如果第一个比第二个大，就交换位置。
2 从第一对开始，对数组中的每一对相邻的两个元素重复步骤1，使得最大的元素沉到数组底部。
3 重复步骤2，除了底部已经排序好的元素。(每一趟都会多一个以排序好的元素)
4 重复以上步骤直到排序完成。

算法分析：

最好：T(n)=O(n);数据全部正序
最差：T(n)=O(n^2);数据全部反序
平均：T(n)=O(n^2);

代码实现

#include<iostream>
using namespace std;
void swap(int &a, int &b) {
  //交换函数
    int tmp = a;
    a = b;
    b = tmp;
}
void bubbleSort(int a[],int len) {
    for (int i = 0; i < len; ++i) {
  //排列len趟完成排序
        for (int j = 0; j < len - i - 1; ++j) {
  //每趟排序的元素都从第一个元素开始到尾部没有排序好的元素。第一趟为第一个元素到最后一个元素，排出了最大元素。第二趟为第一个元素到倒数第二个元素(排除以排序好的元素)，排出第二大的元素。
            if (a[j] > a[j + 1]) {
                swap(a[j], a[j + 1]);
            }
        }
    }
}
int main() {
    int a[] = { 520,0,1,9,56,100,1,85,5,3,6 };
    int len = sizeof(a) / sizeof(a[0]);
    bubbleSort(a, len);
    for (int i = 0; i < len; ++i) {
        cout << " " << a[i];
    }
    getchar();
    return 0;
}
//运行结果：
 0 1 1 3 5 6 9 56 85 100 520

算法改进

1**增加了反向冒泡。传统冒泡排序每一趟排序一次，找出一个最大值。改进后每一趟排序两次,正向冒泡，找出最大的元素；反向冒泡，找出最小元素，使得一次可以得到两个最终值。从而减少排序趟数。**
2**增加了标志点flag**。目的在于记录每一趟最后一次交换的元素位置，即表示标志点之后或者之前的位置已经排好，后续无需再排，缩小排序区间，减少排序次数。

#include<iostream>
using namespace std;
void swap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}
void bubbleSort(int a[],int len) {
    int low = 0, high = len - 1;
    while (low < high) {
  //排序趟数。排序区间[low,high]。
        int flag = 0;//标志点
        for (int i = low; i < high; ++i) {
  //第一次正向冒泡
            if (a[i] > a[i + 1]) {
                swap(a[i], a[i + 1]);
                flag = i;
            }
        }
        high = flag;//表示标志点之后的元素已经排好，区间右值缩小。
        for (int i = high; i > low; --i) {
  //第2次反向冒泡
            if (a[i] < a[i - 1]) {
                swap(a[i], a[i - 1]);
                flag = i;
            }
        }
        low = flag;//表示断点之前的元素已经排好，区间左值缩小。  
    }
}
int main() {
    int a[] = { 520,0,1,9,56,100,1,85,5,3,6 };
    int len = sizeof(a) / sizeof(a[0]);
    bubbleSort(a, len);
    for (int i = 0; i < len; ++i) {
        cout << " " << a[i];
    }
    getchar();
    return 0;
}
//运行结果：
 0 1 1 3 5 6 9 56 85 100 520

2选择排序(Select Sort)

简述

将数组分为已排序和待排序两个区间，即有序区和无序区。每次从无序区中选出最小/最大的元素与无序区的第一个元素（即有序区尾部）交换位置，直到无序区只剩一个元素，排序完成。

算法描述

1 将数组划分为有序区和无序区。（开始有序区为空，无序区[0,n-1]）
2 在无序区中找出最大的那个元素，与该区间第一个元素交换。（有序区元素个数加1，无序区减1）
3 重复步骤2 n-1次，排序完成。（排序趟数为n-1，最后一个元素无需排序)

算法分析

时间复杂度最稳定，无论什么时候都为：T(n)=0(n^2)

代码实例

#include<iostream>
using namespace std;
void swap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}
void selectSort(int a[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        int minIndex = i;
        for (int j = i; j < len; ++j) {
  //找出无序区最小元素的下标