912.排序组合

快排思想：超时 20/21

采用“分治”思想，选择一个基准元素base，通常选择第一个元素或者最后一个元素，通过第一轮扫描，比base小的元素都在base左边，比base大的元素在base右边，再有同样的方法递归排序这两部分，直到序列中所有数据均有序为止。

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        quickSort(nums, 0, nums.size() - 1);
        return nums;
    }

    void quickSort(vector<int>& nums, int start, int end) {
        //分治思想，每次都分成两半进行排序
        if (start >= end) return;

        //确定基准数
        int base = nums[start];
        int left = start;
        int right = end;
        while (left < right) {
            //从右往左，大于base，right--
            while (left < right && nums[right] >= base ) right--;
            //小于base，取代left
            nums[left] = nums[right];
            while (left < right && nums[left] <= base) left++;
            nums[right] = nums[left];
        }
        //当left和right指向同一元素时，base替换到此处
        nums[left] = base;
        //递归
        quickSort(nums, start, left - 1);
        quickSort(nums, left + 1, end);
    }
};

---

冒泡排序：会超时 10/21

3，9，-1，10，20-->3，-1，9，10，20 第一轮 排序4次 j = nums.size() - 1

-1，3，9，10，20-->-1，3，9，10，20 第二轮，排序3次 j = nums.size()- 1 -1

每次循环外加大循环。

第一轮，

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        for (int i = 0; i < nums.size()  - 1; i++) {
            for (int j = 0; j < nums.size() - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp; 
                }
            }
        }
        return nums;
    }
};

优化：

如果一轮排序后发现没有交换，则说明是有序的，用flag进行标记

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        bool flag = false;
        for (int i = 0; i < nums.size()  - 1; i++) {
            for (int j = 0; j < nums.size() - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    flag = true;
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp; 
                }
            }
            if (flag == false) {
                //再进行完一轮的排序之后，判断本轮是否发生了元素之间的交换
                //如果没有发生交换，说明数组已经是有序的了，直接结束排序
                break;
            }else {
                //如果发生了交换，那么在下一轮排序之前将flag再次置为false
                //以便记录下一轮排序的时候是否会发生交换
                flag = false;
            }
        }
        return nums;
    }
};