常见的排序算法

直接插入排序

整个序列分为有序区和无序区，取第一个元素作为初始有序区，然后第二个开始，依次插入到有序区的合适位置，直到排好序。

void InsertSort(vector<int> &num){
    for(int i = 1;i < num.size();++i){
        for(int j = i;j > 0;--j){
            if(num[j] < num[j - 1]){
                int temp = num[j];
                num[j] = num[j-1];
                num[j-1] = temp;
            }
        }
    }
}

插入排序的时间复杂度最好的情况是已经是正序的序列，只需比较(n-1)次，时间复杂度为O(n)，最坏的情况是倒序的序列，要比较n(n-1)/2，时间复杂度为O(n²)平均的话要比较时间复杂度为O(n²)。
插入排序是一种稳定的排序方法，排序元素比较少的时候，大量元素便会效率低下。

冒泡排序

比较相邻的元素，如果反序则交换，过程也是分为有序区和无序区，初始时有序区为空，所有元素都在无序区，经过第一趟后就能找出最大的元素，然后重复即可。

void BubbleSort(vector<int>& nums){
    for(int i = 0;i < nums.size() - 1; i++){
        for(int j = 0;j < nums.size() - i - 1; j++){
            if(nums[j] > nums[j+1]){
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
}

冒泡排序感觉非常好理解，第一个for循环是遍历所有元素，第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较，若反序则交换。
时间复杂度最坏的情况是反序序列，要比较n(n-1)/2次，时间复杂度为O(n² )，最好的情况是正序，只进行(n-1)次比较，不需要移动，时间复杂度为O(n)，而平均的时间复杂度为O(n² )。冒泡排序也是一种稳定的排序算法，也是元素较少时效率比较高

快速排序

快速排序首选一个轴值(pivot，也有叫基准的)，将待排序记录划分成独立的两部分，左侧的元素均小于轴值，右侧的元素均大于或等于轴值，然后对这两部分再重复，直到整个序列有序。

int OnceSort(vector<int>& nums,int first,int end){
    int i=first,j=end;
    //当i<j即移动的点还没到中间时循环
    while(i<j){
        //右边区开始，保证i<j并且nums[i]小于或者等于nums[j]的时候就向左遍历
        while(i<j&&nums[i]<=nums[j])j--;
        //这个时候已经跳出循环，说明j>i或者nums[i]大于nums[j]了，如果i<j那就是nums[i]大于nums[j]，那就交换
        if(i<j){
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
        //对另一边执行同样的操作
        while(i<j&&nums[i]<=nums[j])i++;
        if(i<j){
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
    }
    //返回已经移动的一边当做下一次排序的轴值
    return i;
}
void QuickSort(vector<int>& nums,int first,int end){
    if(first<end){
        int pivot=OnceSort(nums,first,end);
        QuickSort(nums,first,pivot-1);
        QuickSort(nums,pivot+1,end);
    }
}

快速排序时间复杂度的最好情况和平均情况一样为O(nlogn)，最坏情况下为O(n² )，这个看起来比前面两种排序都要好，但是这是不稳定的算法，并且空间复杂度高一点O(nlogn)。而且快速排序适用于元素多的情况。

堆排序

堆的结构类似于完全二叉树，每个结点的值都小于或者等于其左右孩子结点的值，或者每个节点的值都大于或等于其左右孩子的值。

堆排序过程将待排序的序列构造成一个堆，选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序。

void Heapify(vector<int>& nums,int first,int end){
    int father=first;
    int son=father*2+1;
    while(son<end){
        if(son+1<end&&nums[son]<nums[son+1])son++;
        //如果父节点大于子节点则表示调整完毕
        if(nums[father]>nums[son])break;
        else {
            //不让就交换父节点和子节点的元素
            int temp=nums[father];
            nums[father]=nums[son];
            nums[son]=temp;
            //父和子节点变成下一关要比较的位置
            father=son;
            son=2*father+1;
        }
    }
}
void HeapSort(vector<int>& nums){
    int i;
    //初始化堆，从最后一个父节点开始
    for(i=nums.size()/2-1;i>=0;i--){
        Heapify(nums,i,nums.size());
    }
    //从堆中的取出最大的元素再调整堆
    for(i=nums.size()-1;i>0;i--){
        int temp=nums[i];
        nums[i]=nums[0];
        nums[0]=temp;
        //调整堆
        Heapify(nums,0,i);
    }
}

堆排序的时间复杂度最好到最坏都是O(nlogn)，较多元素的时候效率比较高。

归并排序

归并排序的基本思想是将若干个序列进行两两归并，直至所有待排序记录都在一个有序序列为止。

void Merge(vector<int>& nums,vector<int>& temp,int start,int end){
    if(start>=end)return;
    int mid=(start+end)/2;
    //分成两部分
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    Merge(nums,temp,start1,end1);
    Merge(nums,temp,start2,end2);

    int k=start;
    //两个序列一一比较,哪的序列的元素小就放进temp序列里面,然后位置+1再与另一个序列原来位置的元素比较
    //如此反复,可以把两个有序的序列合并成一个有序的序列
    while(start1<=end1&&start2<=end2){
        temp[k++]=nums[start1]<nums[start2]?nums[start1++]:nums[start2++];
    }
    //然后这里是分情况,如果nums序列的已经全部都放进temp序列了然后跳出了循环
    //那就表示nums序列还有更大的元素(一个或多个)没有放进temp序列,所以这一步就是接着放
    while(start1<=end1){
        temp[k++]=nums[start1++];
    }
     //这一步和上面一样
     while(start2<=end2){
        temp[k++]=nums[start2++];
     }
     //把已经有序的temp序列放回nums序列中
     for(k=start;k<=end;k++){
        nums[k]=temp[k];
     }
}
void MergeSort(vector<int>& nums){
    //创建一个同样长度的序列,用于临时存放
    vector<int>temp(nums.size());
    Merge(nums,temp,0,nums.size()-1);
}

归并排序的时间复杂度都是O(nlogn)，并且适用于元素较多的时候排序。