【java】NC140_排序数组

题目描述

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]
示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]
提示：1 <= nums.length <= 50000
-50000 <= nums[i] <= 50000

我的解题思路：

一、调用库函数Arrays.sort

public int[] sortArray(int[] nums) {
         Arrays.sort(nums);
         return nums;
    }

 二、冒泡排序（会超时）

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

三、队列优先排序（大根堆）

public int[] sortArray(int[] nums) {
         PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>(){
             public int compare(Integer a, Integer b){
                 return a.compareTo(b);
             }
         });
         for (int i = 0; i < nums.length; i++) {
             queue.add(nums[i]);
         }
         int[] newArr = new int[nums.length];
         for (int j = 0; j < nums.length; j++) {
             newArr[j] = queue.poll();
         }
         return newArr;
    }

四、快速排序

参考博文快速排序

public int[] sortArray(int[] nums) {
        quarkSort(nums, 0, nums.length - 1);
        return nums;
    }
    public void quarkSort (int[] arr, int low, int high) {
        if (low < high) {
            int index = getIndex(arr, low, high);
            quarkSort(arr, low, index - 1);
            quarkSort(arr, index + 1, high);
        }
    }

    public int getIndex (int[] arr, int low, int high) {
        int temp = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= temp) {
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= temp) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = temp;
        return low;
    }

复杂度分析

时间复杂度：基于随机选取主元的快速排序时间复杂度为期望O(nlogn)，其中n 为数组的长度。

空间复杂度：O(h)，其中 h 为快速排序递归调用的层数。我们需要额外的O(h) 的递归调用的栈空间，由于划分的结果不同导致了快速排序递归调用的层数也会不同，最坏情况下需 O(n) 的空间，最优情况下每次都平衡，此时整个递归树高度为logn，空间复杂度为O(logn)。