排序方法动画讲解，go语言实现，博客园大佬真滴多。
https://www.cnblogs.com/onepixel/p/7674659.html
个人理解和C++代码实现
//排序目标是从小到大
冒泡排序：从前到后逐个比较相邻两个数字的大小，如果前大后小就交换，确保每相邻两个数字都是前小后大，每一次遍历后，保证遍历终点位置的数字是遍历过程中最大的（如果有比这个数字更大的，一定会被交换到它的后面）
void BubbleSort(int (&num)[11]){
int n=11;
for(int i=0;i<n;i++){
for(int j=0;j<n-1-i;j++){
if(num[j]>num[j+1]){
int temp=num[j];
num[j]=num[j+1];
num[j+1]=temp;
}
}
}
}
双重循环，时间复杂度为O（log（n^2)）;空间复杂度为O（1）；稳定排序
选择排序：每次从无序序列中选取最小的放到有序序列的末尾，每遍历一次，有序序列就增加一个元素。
void SelectionSort(int (&num)[11]){
int n=11;
for(int i=0;i<n;i++){
//num[0]到num[i-1]是现有有序序列；num[i]到num[n-1]是无序序列；
int minindex=i;
int j=i+1;
for(j=i+1;j<n;j++){
if(num[j]<num[minindex]){
minindex=j;
}
}
swap(num[i],num[minindex]);
}
}
双重循环，时间复杂度为O（log（n^2)）;空间复杂度为O（1）；不稳定排序：涉及到不相邻数字的交换
例如:(7) 2 5 9 3 4 [7] 1...当我们利用直接选择排序算法进行排序时候,(7)和1调换,(7)就跑到了[7]的后面了,原来的次序改变了,这样就不稳定了.
插入排序：为每一个未排序元素在已排序序列中找到位置并插入，只保证已排序序列中元素满足前后大小关系。
void InsertionSort(int (&num)[11]){
int n=11;
//默认第一个数字是有序的
for(int i=1;i<n;i++){
int temp=num[i];
int preindex=i-1;
while(preindex>=0&&num[preindex]>temp){
num[preindex+1]=num[preindex];
preindex--;
}
num[preindex+1]=temp;
}
}
双重循环，时间复杂度为O（log（n^2)）;空间复杂度为O（1）；稳定排序
希尔排序：分组多次进行的直接插入排序，较插入排序有时间上的优化，重要在于gap分组步长的取值
void shellsort1(int (&num)[11]){
int i,j,gap;
int n=11;
for(gap=n/2;gap>0;gap/=2){
for(i=0;i<gap;i++){
for(j=i+gap;j<n;j+=gap){
if(num[j]<num[j-gap]){
int temp=num[j];
int current=j-gap;
while(current>=0&&num[current]>temp){
//while()条件里不能直接用num[j],因为num[j]也是数组
//一部分，会被改变，要用temp存起来它的值
num[current+gap]=num[current];
current-=gap;
}
num[current+gap]=temp;
}
}
}
}
}
void shellsort2(int (&num)[11]){
int n=11;
int i,gap;
//改进在于把三重循环改进成两重循环，将分组进行的插入
//优化成各组交替进行的插入排序
for(gap=n/2;gap>0;gap/=2){
for(i=gap;i<n;i++){
if(num[i]<num[i-gap]){
int temp=num[i];
int current=i-gap;
while(current>=0&&num[current]>temp){
num[current+gap]=num[current];
current-=gap;
}
num[current+gap]=temp;
}
}
}
}
希尔排序的运行时间依赖于增量序列的选择，而证明很复杂。。。。。。
平均时间复杂度按O(nlogn)计算，空间复杂度O(1),,,不稳定排序，因为存在不同组的插入排序。
归并排序：递归的把两个（或多个）有序的子串合并成一个有序的子串，递归到底就是把两个单独的数排序，中心思想在于合并，分治的一种体现
void merge(int num[],int low,int mid,int high){
int *temp=new int[high-low+1];
int leftindex=low;
int rightindex=mid+1;
int tempk=0;
while(leftindex<=mid&&rightindex<=high){
if(num[leftindex]<num[rightindex]){
temp[tempk]=num[leftindex];
tempk++;
leftindex++;
}
else{
temp[tempk]=num[rightindex];
tempk++;
rightindex++;
}
}
while(leftindex<=mid){
temp[tempk] = num[leftindex];
tempk++;
leftindex++;
}
while(rightindex<=high){
temp[tempk] = num[rightindex];
tempk++;
rightindex++;
}
for(int i=low,tempk=0;i<=high,tempk<=high-low;i++,tempk++){
num[i]=temp[tempk];
}
delete []temp;
}
void MergeSort(int num[],int low,int high){
if(low>=high){
return ;
}
int mid=low+(high-low)/2;
MergeSort( num,low,mid);
MergeSort(num,mid+1,high);
merge(num,low,mid,high);
}
时间复杂度一直是O(nlogn)不随输入改变，空间复杂度O(n),稳定排序