NC140 排序，2021-4-27

NC140 排序

https://www.cnblogs.com/onepixel/p/7674659.html
https://www.runoob.com/w3cnote/sort-algorithm-summary.html

简单冒泡，时间复杂度O(n^2)，超时不通过

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int i,j;
        int temp;
        int length=arr.size();
        for (i=0;i<length;i++)
        {   for (j=i+1;j<length;j++)
                {
                    if(arr[i]>arr[j])
                    {
                        temp=arr[j];
                        arr[j]=arr[i];
                        arr[i]=temp;
                    }
                }
        }        
        return arr;
        
    }
};

插入排序，时间复杂度O(n^2),超时不通过

    vector<int> MySort(vector<int>& arr) {
        // write code here
        int i,j;
        int preIndex=0;
        int length=arr.size();
        int current;
        for (i=1;i<length;i++)
        {   
            preIndex=i-1;         //排完序的部分
            current=arr[i];       //现在比较的数
            while (preIndex>=0 && arr[preIndex]>current) 
            {     //当前值比排完序中数小时执行，把排完序中大的那个值后放一位
                arr[preIndex + 1] = arr[preIndex]; //若有多个，则都后放
                preIndex--; 
//不会出现多个大于中间出现一个小于，因为是从序号1开始，那么排完序的必然是从小到大，避免了覆盖丢失的问题。
            }
            arr[preIndex+1]=current;   //最后再把当前值插入，
        }
        
        return arr;
    }
};

快速排序，时间复杂度O(n*log n)，通过

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    vector<int> MySort(vector<int>& arr) 
    {
        // write code here
        quicksort(arr, 0, arr.size()-1);
        return arr;
    }
    
    void quicksort(vector<int>& arr,int left,int right)
    {
        if(left>right)
            return;
        
        int stan_index=quicksort_part(arr,left,right);
        quicksort(arr,left,stan_index-1);     //对标杆左边的子数组排序
        quicksort(arr,stan_index+1,right);     //对标杆右边的子数组排序
    }
    
    int quicksort_part(vector<int>& arr,int left,int right)
    {
        //int standard=right;   //最右边第一个为标杆,可以省略这个变量，用right
        //int count=0;      错误！！！！！ 这样在运行时会一直从arr[0]开始调换！！！
        int count=left;
        while(left<right)
        {
            if(arr[left]<arr[right])
            {
              swap(arr[left],arr[count]);
              count++;//计数，比标准小的个数,其实也是记住第一个比标准大的索引，最后将标准与此交换
   //举例，arr为 0大 1小 2大 3小 4小 5标准
   //当arr[0]比标准大，则处理后conut=0,left=1    0大
   //遇到arr[1]小于标准时,把arr[0]和arr[1]交换，即把大的放到了arr[1]然后count=1，left=2  1小 0大
   //遇到arr[2]大于标准时，count=1,left=3   此时 1小 0大 2大
   //遇到arr[3]小于标准时，交换arr[1]和arr[3],此时 1小 3小 2大 0大，count=2,left=4
   //遇到arr[4]小于标准时,交换arr[2]和arr[4],此时1小 3小 4小 0大 2大 5标准
   //count=3,left=5
   //最后交换 arr[count],arr[right]，即交换arr[3],arr[5] 
            }
              left++;//到下一位处理
        }
        swap(arr[count],arr[right]);    //找到数组中所有小于标准的个数，则标准放在arr[count]处
        return count;
    }
    
};