排序算法1

冒泡排序，时间复杂度O(n2)，空间复杂度为O(1)

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 0; i < nums.length; i++){
            for (int j = 1; j < nums.length - i; j++){
                if(nums[j] < nums[j-1]){
                    int tmp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = tmp;
                }
            }
        }

        return nums;
    }
}

选择排序，时间复杂度为O(n2)，空间复杂度为O(1)

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 0; i < nums.length; i++){
            int min = i;
            for (int j = i; j < nums.length; j++){
                if(nums[j] < nums[min]){
                    min = j;
                }
            }
            int tmp = nums[i];
            nums[i] = nums[min];
            nums[min] = tmp;
        }
        return nums;
    }
}

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 1; i < nums.length; i++){
            for (int j = i; j > 0; j--){
                if(nums[j] < nums[j-1]){
                    int tmp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = tmp;
                }else{
                    break;
                }
            }
        }
        return nums;
    }
}

插入排序，时间复杂度为O(n2)，空间复杂度为O(1)

class Solution {
    public int[] sortArray(int[] nums) {
        for (int i = 1; i < nums.length; i++){
            for (int j = i; j > 0; j--){
                if(nums[j] < nums[j-1]){
                    int tmp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = tmp;
                }else{
                    break;
                }
            }
        }
        return nums;
    }
}

快速排序,时间复杂度O(NLogN)，空间复杂度为O(1)

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

    public void qort(int left, int right, int[] nums){
        if(left < 0 || right > nums.length -1 || left + 1 > right){
            return;
        }

        int standard =  nums[left];
        int i  = left + 1, j= 0;
        for (; i <= right - j;){
            if(nums[i] < standard){
                int tmp = nums[i-1];
                nums[i-1] = nums[i];
                nums[i] = tmp;
                i++;
            }else{
                int tmp = nums[i];
                nums[i] = nums[right - j];
                nums[right - j] = tmp;
                j++;
            }
        }
        qort(left, right - j - 1, nums);
        qort(right - j + 1, right, nums);

    }
}

归并排序，时间复杂度为O(NlogN)

class Solution {
    public int[] sortArray(int[] nums) {
        merge(0,nums.length -1, (nums.length-1) / 2, nums);
        return nums;
    }

    public void merge(int left, int right, int mid, int[] nums){
        if(left == right){
            return;
        }

        merge(left, mid, (left+mid)/2, nums);
        merge(mid + 1, right, (right+mid + 1)/2, nums);
        int[] tmp = new int[right-left+1];
        int leftindex = left;
        int midindex = mid + 1;
        int index = 0;

        while(leftindex <= mid && midindex <= right){
            if(nums[leftindex] < nums[midindex]){
                tmp[index++] = nums[leftindex++];
            }else{
                tmp[index++] = nums[midindex++];
            }
        }
        while (leftindex <= mid){
             tmp[index++] = nums[leftindex++];
        }
        while (midindex <= right){
             tmp[index++] = nums[midindex++];
        }

        for (int i = 0 ; i < index; i++){
            nums[left++] = tmp[i];
        }
    }
}