leetcode-排序

1、题目

给定一个长度为 n 的数组，请你编写一个函数，返回该数组排序后的结果。
如输入：[5,2,3,1,4]
输出：[1,2,3,4,5]

要求：要求：空间复杂度 O(n)，时间复杂度 O(nlogn)。

2、思路

就是考排序，用冒泡排序、选择排序、插入排序和快速排序尝试。

3、代码

冒泡排序：

vector<int> MySort(vector<int>& arr) {
        //冒泡排序
        int len = arr.size();
        for(int i=len-1; i>0; i--){
            for(int j=0; j < i; j++){
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
        return arr;
        }

冒泡排序结果超时。
选择排序：

   //选择排序
   vector<int> MySort(vector<int>& arr) {
        int len = arr.size();
        for(int i=0; i<len; i++){
            int minindx = i;
            for(int j = i+1; j<len; j++){
                if(arr[minindx]>arr[j]){
                    minindx = j;
                }
            }
            this->swap(arr, i, minindx);
        }
        return arr;
    };
    
    void swap(vector<int> &arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    };

选择排序结果超时。
插入排序：

    vector<int> MySort(vector<int>& arr) {
        //插入排序
        int j;
        for(int i = 1; i < arr.size();i++)
        {
            int tmp = arr[i];
            for(j=i; j>0 && tmp < arr[j-1]; j--)
            {
                arr[j] = arr[j-1];
            }
            arr[j] = tmp;
        }
        return arr;
        };

插入排序结果超时。
快速排序：

    vector<int> MySort(vector<int>& arr) {
        //快速排序
         this->quicksort(arr, 0, arr.size()-1);
         return arr;
         }
         
    void quicksort(vector<int> &arr, int i, int j){
        int l = i;
        int r = j;
        int pvot=arr[i];
        if (l>=r){
            return;
        }
        while(r > l){
            while(r > l && arr[r] >= pvot){
                r--;
            }
            if(r > l){
                arr[l]=arr[r];
                l++;
            }
            while(r > l && arr[l] <= pvot){
                l++;
            }
            if(r > l){
                arr[r]=arr[l];
                r--;
            }
        }

        arr[r] = pvot;
        quicksort(arr, i, l-1);
        quicksort(arr, l+1, j);
    }

快速排序满足要求。通过。