排序篇

排序方法动画讲解，go语言实现，博客园大佬真滴多。
https://www.cnblogs.com/onepixel/p/7674659.html
个人理解和C++代码实现
//排序目标是从小到大
冒泡排序：从前到后逐个比较相邻两个数字的大小，如果前大后小就交换，确保每相邻两个数字都是前小后大，每一次遍历后，保证遍历终点位置的数字是遍历过程中最大的（如果有比这个数字更大的，一定会被交换到它的后面）

void BubbleSort(int (&num)[11]){
    int n=11;
    for(int i=0;inum[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

双重循环，时间复杂度为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=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=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=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]=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),稳定排序