leetcode 912. 排序数组【排序】

很直接的排序题，可以用来复习一下几种排序算法：

方法1：插入排序

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

方法2：冒泡排序

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

方法3：选择排序

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

方法4：归并排序

class Solution {
    public int[] sortArray(int[] nums) {
        if(nums.length<2)return nums;
        int[] left = Arrays.copyOfRange(nums,0,nums.length/2);
        int[] right = Arrays.copyOfRange(nums,nums.length/2,nums.length);
        return merge(sortArray(left), sortArray(right));
    }
    
    public int[] merge(int[] left, int[] right){
        int[] res = new int[left.length+right.length];
        int leftIndex = 0;
        int rightIndex = 0;
        int index=0;
        while(index<res.length){
            if(leftIndex<left.length && rightIndex<right.length){
                res[index] = left[leftIndex] < right[rightIndex]?left[leftIndex++]:right[rightIndex++];
            }else if(leftIndex>=left.length&&rightIndex<right.length){
                res[index] = right[rightIndex++];
            }else if(rightIndex>=right.length && leftIndex<left.length){
                res[index] = left[leftIndex++];
            }
            index++;
        }
        return res;
    }
}

方法5：计数排序

class Solution {
    public int[] sortArray(int[] nums) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for(int i=0; i<nums.length;i++){
            max = Math.max(max, nums[i]);
            min = Math.min(min, nums[i]);
        }
        int[] arr = new int[max-min+1];
        
        for(int i=0; i<nums.length;i++){
            arr[nums[i]-min]++;
        }
        int index=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i] != 0){
                while(arr[i]!=0){
                    nums[index++]=i+min;
                    arr[i]--;
                }
            }
        }
        return nums;
        
    }
}

方法6：堆排序

class Solution {
    public int[] sortArray(int[] nums) {
        buildHeap(nums);
        return nums;
    }
    public void buildHeap(int[] nums){
        for(int i=nums.length/2-1; i>=0;i--){
            adjust(nums, i, nums.length);
        }
        for(int j=nums.length-1; j>=0; j--){
            swap(nums, 0, j);
            adjust(nums,0,j);
        }
    }
    public void adjust(int[] nums, int i, int len){
        int temp = nums[i];
        for(int j=i*2+1; j<len; j=j*2+1){
            if(j+1<len && nums[j]<nums[j+1])j++;
            if(temp<nums[j]){
                nums[i] = nums[j];
                i=j;
            }else{
                break;
            }
        }
        nums[i] = temp;
    }

    public void swap(int[] nums, int i, int j){
        int temp=nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

方法7：希尔排序

class Solution {
    public int[] sortArray(int[] nums) {
        for(int i=nums.length/2; i>0; i=i/2){
            for(int j=i; j<nums.length;j++){
                if(nums[j]<nums[j-i]){
                    int temp=nums[j];
                    int k;
                    for(k=j-i;k>=0&&temp<nums[k];k-=i){
                        nums[k+i] = nums[k];
                    }
                    nums[k+i] = temp;
                }
            }
        }
        return nums;
    }
}

方法8：快速排序

class Solution {
    public int[] sortArray(int[] nums) {
        quicksort(nums,0,nums.length-1);
        return nums;
    }
    public void quicksort(int[] nums, int i, int j){
        if(i>j)return;
        int temp = nums[i];
        int low=i;
        int high = j;
        while(low<high){
            while(low<high && nums[high]>=temp)high--;
            nums[low] = nums[high];
            while(low<high && nums[low]<=temp)low++;        
            nums[high] = nums[low];
        }
        nums[low] = temp;
        quicksort(nums, i,low-1);
        quicksort(nums, low+1, j);

    }
}