1.冒泡排序

将一个数组从小到大排序，一次循环（从头开始遍历，将相邻的两个数值比较，如果前面一个大于后面的数字，交换这两个数字）可以将循环数组中的最大值放在最后面，经过多次冒泡就可以完成排序

平均时间复杂度	$O(n^2)$
最坏时间复杂度	$O(n^2)$
最好时间复杂度	$O(n)$
空间复杂度	O(1)

#include<iostream>
#include<vector>using namespace std;//1.冒泡算法
void bubblesort(vector<int>& array,int N) {for (int i = 0; i < N; i++) {for (int j = 0; j < N - 1 - i; j++) {if (array[j] > array[j + 1]) {swap(array[j], array[j + 1]);}}}
}

2.选择排序

一次循环，找出最大值，与最后一个值做交换，执行多次循环

#include<iostream>
#include<vector>
using namespace std;//2.选择排序
void selectsort(vector<int>& array, int N) {for (int i = 0; i < N; i++) {int max = array[0];int location = 0;for (int j = 0; j < N - i; j++) {if (array[j] > max) {max = array[j];location = j;}}swap(array[location], array[N - 1 - i]);}
}
int main() {vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };selectsort(array, array.size());for (int i = 0; i < array.size(); i++) {cout << array[i] << " ";}cout << endl;
}

3.插入排序

假设数组i位置前面的（0~i-1）个元素，是有序数组（从小到大），在前面的有序数组中插入第i个元素，从后向前，依次和第i个元素比较，大的向后，直到插入合适位置，循环N-1次就可以完成排序。

#include<iostream>
#include<iostream>
#include<vector>
using namespace std;//3.插入排序
void insertsort(vector<int>& array,int N) {for (int i = 1; i < N; i++) {int n = i;while (n>0&&array[n] < array[n-1]) {swap(array[n], array[n - 1]);n--;}}
}
int main() {vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };insertsort(array, array.size());for (int i = 0; i < array.size(); i++) {cout << array[i] << " ";}cout << endl;
}

参考链接：插入排序

4.快速排序

选定数组中一个数pivot作为中心轴
将大于pivot的数放在pivot的右边，将小于pivot的数放在pivot的左边
分别对左右子序列重复第一步第二步的操作

平均时间复杂度	$O(nlo{g}_{2}n)$
最坏时间复杂度	$O(n^2)$
最好时间复杂度	$O(nlo{g}_{2}n)$
空间复杂度	$O(nlo{g}_{2}n)$

#include<iostream>
#include<vector>
using namespace std;void quicksort(vector<int>& array, int left,int right) {if (left >= right) {return;}int l = left;int r = right;while (l < r) {while (array[left] <= array[r] && l < r) {r--;}while (array[left] >= array[l] && l < r) {l++;}swap(array[l], array[r]);}swap(array[left], array[l]);quicksort(array, left, l - 1);quicksort(array, l + 1, right);
}
int main() {vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };quicksort(array, 0, array.size() - 1);for (int i = 0; i < array.size(); i++) {cout << array[i] << " ";}cout << endl;
}

参考链接：快速排序

5.堆排序

构造一个大顶堆/小顶堆，取堆顶数字，也就是最大值/最小值
再将剩下的数字构建一个大顶堆/小顶堆，，取堆顶数字
重复以上的操作，直到取完堆中的数字，得到一个从大到小/从小到大的有序数组

#include<iostream>
#include<iostream>
#include<vector>using namespace std;//5.堆排序
void HeapSort(vector<int>& result, int count, int location) {if (location<0 || location>count) {return;}int left_location = 2 * location + 1;int right_locaton = 2 * location + 2;int max = result[location];if (left_location < count && max < result[left_location]) {max = result[left_location];}if (right_locaton < count && max < result[right_locaton]) {max = result[right_locaton];}if (max != result[location]) {if (left_location < count && max == result[left_location]) {result[left_location] = result[location];HeapSort(result, left_location, count);}else if (right_locaton < count && max == result[right_locaton]) {result[right_locaton] = result[location];HeapSort(result, right_locaton, count);}result[location] = max;}
}
vector<int> heap_sort(int array[], int N) {vector<int> result;for (int i = 0; i < N; i++) {result.push_back(array[i]);}for (int count = N; count > 0; count--) {for (int location = count / 2; location >= 0; location--) {HeapSort(result, count, location);}int value = result[0];result[0] = result[count - 1];result[count - 1] = value;}return result;
}
int main()
{int array[] = { 2,6,1,5,0,8,4,3 };int N = sizeof(array)/4;vector<int> sorted;//sorted= bubble_sort(array, N);//sorted = select_sort(array, N);//sorted = insertion_sort(array, N);//sorted = quick_sort(array, N);sorted = heap_sort(array, N);for (int i = 0; i < sorted.size(); i++) {cout << sorted[i] << " ";}cout << endl;return 0;}

参考链接：
堆排序算法
排序算法
图解排序算法(三)之堆排序

6.归并排序

将数组中的数分为若干组，开始各组数字都是单个元素
两两排序归并，保证归并后的数组是有序的
重复上面两步，直到合成一个组

平均时间复杂度	$O(nlo{g}_{2}n)$
最坏时间复杂度	$O(nlo{g}_{2}n)$
最好时间复杂度	$O(nlo{g}_{2}n)$
空间复杂度	$O(n)$

#include<iostream>
#include<vector>using namespace std;//6.归并排序
void mergesort(vector<int>& array, int left, int right) {if (left >= right) {return;}int mid = (left + right) / 2;mergesort(array, left, mid);mergesort(array, mid + 1, right);int l = left;int r = mid + 1;vector<int> tmp;while (l <= mid && r <= right) {if (array[l] > array[r]) {tmp.push_back(array[r]);r++;}else {tmp.push_back(array[l]);l++;}}while (l <= mid) {tmp.push_back(array[l]);l++;}while (r <= right) {tmp.push_back(array[r]);r++;}for (int i = 0; i <= right - left; i++) {array[i + left] = tmp[i];}
}int main() {vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };//quicksort(array, 0, array.size() - 1);//bubblesort(array, array.size());mergesort(array, 0, array.size() - 1);for (int i = 0; i < array.size(); i++) {cout << array[i] << " ";}cout << endl;
}

参考链接：

归并排序算法讲解
十分钟学会写归并排序

7.希尔排序

该方法的基本思想是：
先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，
然后依次缩减增量再进行排序，
待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

#include<iostream>
#include<iostream>
#include<vector>using namespace std;//7.希尔排序
void shell_swap(int a, int b, vector<int>& result) {int temp = result[a];result[a] = result[b];result[b] = temp;
}
vector<int> shell_sort(int array[], int N) {vector<int> result;for (int i = 0; i < N; i++) {result.push_back(array[i]);}for (int gap = N / 2; gap > 0; gap--) {for (int i = gap; i < N; i++) {for (int j = i - gap; j >= 0 && result[j] > result[j + gap]; j -= gap) {shell_swap(j, j + gap, result);}}}return result;
}int main()
{int array[] = { 2,6,1,5,0,8,4,3,10 };int N = sizeof(array)/4;vector<int> sorted;//sorted= bubble_sort(array, N);//sorted = select_sort(array, N);//sorted = insertion_sort(array, N);//sorted = quick_sort(array, N);//sorted = heap_sort(array, N);//sorted = merge_sort(array, N);sorted = shell_sort(array, N);for (int i = 0; i < sorted.size(); i++) {cout << sorted[i] << " ";}cout << endl;return 0;}

参考链接：

[算法]六分钟彻底弄懂希尔排序，简单易懂
白话经典算法系列之三 希尔排序的实现