class Solution {
    public int[] sortArray(int[] nums) {
        //这种方法超时【快速排序】
        for (int i=0;i<nums.length-1;i++){
            int minIndex = i;//假设当前开始下标为最小元素下标
            for (int j=i+1;j<nums.length;j++){
                //从i到nums。length-1区间里找到最小值下标
                if (nums[j]<nums[minIndex]) minIndex = j;
            }
            //交换i和真正的minIndex元素
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
        }
        return nums;
    }
}

class Solution {
    public int[] sortArray(int[] nums) {
        //插入排序，但是效率比较低
        for (int i=1;i<nums.length;i++){
            int temp = nums[i];
            int tempIndex = i;
            //如过当前下标之前的元素大于当前值，则之前的元素后移，插入当前元素
            while(tempIndex>0 && nums[tempIndex-1]>temp){
                nums[tempIndex] = nums[tempIndex-1];
                tempIndex--;
            }
            nums[tempIndex] = temp;
        }
        return nums;
    }
}

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;

    }
    private void quickSort(int[] nums, int left, int right){
       //测试用例通过了，但是耗时太长，不应该选择最左边，应该随机选择
        if (right==left) return;
        //pivot[左边放小的，右边放大的，左右指标相等时放pivot]
        //int pIndex = rand(right-left+1) + left;
        int pivot = nums[left];
        int l = left;
        int r = right;
        while(l<r){

            //先看右边
            while(l<r && nums[r]>=pivot) r--;
            if (l<r && nums[r]<pivot){
                nums[l] = nums[r]; 
                l++;
            }
            //再看左边
            while(l<r && nums[l]<=pivot) l++;
            if (l<r && nums[l]>pivot){
                nums[r] = nums[l];
                r--;
            }
            if (l==r){
                nums[l] = pivot;
                break;
            }
        }
        if (left<l){
            quickSort(nums,left,l-1);
        }
        if (right>l){
            quickSort(nums,l+1,right);
        }
        
    }

}

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;

    }
    private void quickSort(int[] nums, int left, int right){
        if (right==left) return;
        //pivot[左边放小的，右边放大的，左右指标相等时放pivot]
        int pIndex = (right+left)/2;
        int pivot = nums[pIndex];
        int l = left;
        int r = right;
       do{
            //先看右边
            while(nums[r]>pivot) r--;
            //再看左边
            while(nums[l]<pivot) l++;
            //这是存在左右都不满足条件
            //交换两个元素位置
            if (l<=r){
                int temp = nums[r];
                nums[r] = nums[l];
                nums[l] = temp;
                l++;
                r--;
            }
        }while(l<=r);
        
            if (left<r) quickSort(nums,left,r);
            
            if (right>l) quickSort(nums,l,right);
    }

}