1. //给你一个整数数组 nums，请你将该数组升序排列。 
  2. //
  3. // 
  4. //
  5. // 
  6. // 
  7. //
  8. // 示例 1： 
  9. //
  10. // 输入：nums = [5,2,3,1]
  11. //输出：[1,2,3,5]
  12. // 
  13. //
  14. // 示例 2： 
  15. //
  16. // 输入：nums = [5,1,1,2,0,0]
  17. //输出：[0,0,1,1,2,5]
  18. // 
  19. //
  20. // 
  21. //
  22. // 提示： 
  23. //
  24. // 
  25. // 1 <= nums.length <= 50000 
  26. // -50000 <= nums[i] <= 50000 
  27. // 
  28. // 👍 234 👎 0

老生常谈的一道排序题啊，想不到你浓眉大眼的力扣也有这种小题目

皮一下

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

快排

快排是我很喜欢又经常容易忘的一种排序，因为可以解决topK的问题，做一下记录吧。


class Solution {

    public int[] sortArray(int[] nums) {

        quickSort(nums, 0, nums.length - 1);
        return nums;
    }

    // 对[left,right]范围进行快速排序
    public void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return ;
        }
        int i = left;
        int j = right;
        // 随便选一个数字，以该数字为划分，大于该数字的放到右边，小于该数字的放到左边
        int n = nums[left];
        while (i < j) {
            // 从右边找，找小于该数字的第一个位置
            while (i < j && nums[j] >= n) {
                j --;
            }
            // 从左边开始找，找大于该数字的第一个位置
            while (i < j && nums[i] <= n) {
                i ++;
            }
            // 这里的问题在于，为什么要先移动右边？
            // 如果先走左边，i为停留在第一个大于该数字的位置，此时如果j也停到了这个位置，就会执行更下面的操作，将n放到当前位置。
            // 但是此时i位置的数是大于n的，随机取的数字又是在左边。
            // 这就相当于将一个大于n的数字移动到了左边，这次划分就没有达到想要的效果

            // 找到了需要交换的位置，将大的放右边，小的放左边
            if (i < j) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }
        // 移动结束，此时i==j。
        // 且这个位置在整个[left,right]中，左边都小于等于n，右边都大于等于n
        nums[left] = nums[i];
        nums[i] = n;
        // 继续划分左右的位置
        quickSort(nums, left, i - 1);
        quickSort(nums, i + 1, right);
    }
}