【LeetCode】912. 排序数组

题目链接：

912. 排序数组

题目描述：

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

示例：

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

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

提示：

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

思路：

没什么可说的，非常朴实无华的一道题，比那些花里胡哨的强多了

class Solution {
    public int[] sortArray(int[] nums) {
        // 方法一：系统方法
        // Arrays.sort(nums);
        // return nums;

        // 方法二：冒泡排序（超出时间限制）
        // bubbleSort(nums);
        // return nums;

        // 方法三：桶排序
        return bucketSort(nums);

        // 方法四：选择排序
        // selectionSort(nums);
        // return nums;

        // 方法五：插入排序
        // insertionSort(nums);
        // return nums;
    }

    /**
     * 冒泡排序
     * @param nums
     */
    private void bubbleSort(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                }
            }
        }
    }

    /**
     * 桶排序
     * @param nums
     * @return
     */
    private int[] bucketSort(int[] nums) {
        // 题目：-50000 <= nums[i] <= 50000
        int[] count = new int[100001];
        // 统计每个数字出现的次数
        for (int num : nums) {
            count[num + 50000] ++;
        }

        ArrayList<Integer> list = new ArrayList<>(nums.length);
        for (int i = 0; i < count.length; i++) {
            if (count[i] != 0) {
                for (int j = 0; j < count[i]; j++) {
                    list.add(i - 50000);
                }
            }
        }

        int[] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }

    /**
     * 选择排序
     * @param nums
     */
    private void selectionSort(int[] nums) {
        for (int i = nums.length - 1; i > 0; i--) {
            // 最大元素的位置
            int maxIndex = 0;
            for (int j = 0; j <= i; j++) {
                if (nums[maxIndex]<nums[j]) {
                    maxIndex = j;
                }
            }
            // 把这个最大的元素移到最后
            swap(nums, maxIndex, i);
        }
    }

    /**
     * 插入排序
     * @param nums
     */
    private void insertionSort(int[] nums) {
        // 从第二个元素开始遍历
        for (int i = 1; i < nums.length; i++) {
            int j = i;
            // 将当前元素移动到合适的位置
            while (j > 0 && nums[j] < nums[j - 1]) {
                swap(nums, j, j - 1);
                j--;
            }
        }
    }
    
    /**
     * 交换数组中两个元素
     * @param nums 数组
     * @param i 元素索引
     * @param j 元素索引
     */
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}