leetcode-排序数组

 题目来自LeetCode，链接：排序数组。具体描述为：给你一个整数数组 nums，请你将该数组升序排列。其中：

• 1 <= nums.length <= 50000
• -50000 <= nums[i] <= 50000

 示例1：

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

 示例2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

 这题就是经典的排序了，不多说了，直接先来个时间复杂度为$O(nlogn)$的快排，其空间复杂度为$O(h)$，其中h为快排递归调用的层数。因为需要额外的$O(h)$的递归调用的栈空间，由于划分的结果不同导致了快排递归调用的层数也会不同，最坏情况下需$O(n)$的空间，最优情况下每次都平衡，此时整个递归树高度为$\log n$，空间复杂度为$O(\log n)$。

 JAVA版代码如下：

class Solution {
    private void swap(int[] nums, int i, int j) {
        if (i != j) {
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }

    private int partition(int[] nums, int left, int right) {
        int i = left - 1;
        int pivot = nums[right];
        for (int j = left; j < right; ++j) {
            if (nums[j] < pivot) {
                swap(nums, ++i, j);
            }
        }
        swap(nums, ++i, right);
        return i;
    }

    private void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int middle = partition(nums, left, right);
        quickSort(nums, left, middle - 1);
        quickSort(nums, middle + 1, right);
    }

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

 提交结果如下:

 当然为了避免极端情况下快排退化到$O(n^2)$，可以加入一点随机化。

 JAVA版代码如下：

class Solution {
    private void swap(int[] nums, int i, int j) {
        if (i != j) {
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }

    private int random_partition(int[] nums, int left, int right) {
        int idx = left + (int)Math.random() % (right - left + 1);
        swap(nums, idx, right);
        return partition(nums, left, right);
    }

    private int partition(int[] nums, int left, int right) {
        int i = left - 1;
        int pivot = nums[right];
        for (int j = left; j < right; ++j) {
            if (nums[j] < pivot) {
                swap(nums, ++i, j);
            }
        }
        swap(nums, ++i, right);
        return i;
    }

    private void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int middle = random_partition(nums, left, right);
        quickSort(nums, left, middle - 1);
        quickSort(nums, middle + 1, right);
    }

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

 提交结果如下:

 emmm，这里效果没之前好是因为测试数据比较少，可能并没有太多极端情况比如倒序数组的情况出现。

 另外由于此题目的数是有范围的，所以也可以采用计数排序，其时间复杂度为$O(n)+O(C)$，空间复杂度为$O(C)$，其中C为数的范围，这里就是100001。

 JAVA版代码如下：

class Solution {
    
    public int[] sortArray(int[] nums) {
        int N = 100001;
        int bias = 50000;
        int[] countNums = new int[N];
        for (int num : nums) {
            ++countNums[num + bias];
        }
        int count = 0;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < countNums[i]; ++j) {
                nums[count++] = i - bias;
            }
        }
        return nums;
    }
}

 提交结果如下: