算法---LeetCode 384. 打乱数组

1. 题目

原题链接

给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。
实现 Solution class:

Solution(int[] nums) 使用整数数组 nums 初始化对象
int[] reset() 重设数组到它的初始状态并返回
int[] shuffle() 返回数组随机打乱后的结果

示例：

输入
[“Solution”, “shuffle”, “reset”, “shuffle”]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
解释
Solution solution = new Solution([1, 2, 3]);
solution.shuffle(); // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如，返回 [3,
1, 2]
solution.reset(); // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]
solution.shuffle(); // 随机返回数组 [1, 2, 3] 打乱后的结果。例如，返回 [1, 3, 2]

2. 题解

2.1 解法1: 暴力法

1. 初始化时, 使用一个辅助数组来保存 数组的初始状态值
2. 在进行打乱时, 每次生成随机数, 从数组中取出一个值并赋值给 arr

    class Solution {
        int[] arr;
        int[] origin;
        Random random = new Random();
        public Solution(int[] nums) {
            arr = nums;
            origin = nums.clone();
        }
        /**
         * Resets the array to its original configuration and return it.
         */
        public int[] reset() {
            arr = origin;
            origin = origin.clone();
            return arr;
        }
        /**
         * Returns a random shuffling of the array.
         */
        public int[] shuffle() {
            // 先将数组转为 list
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < arr.length; i++) {
                list.add(arr[i]);
            }
            for (int i = 0; i < arr.length; i++) {
                int index = random.nextInt(list.size());
                arr[i] = list.get(index);
                list.remove(index);
            }
            return arr;
        }
    }

2.2 解法2: 洗牌算法

思路和解法1 基本一致, 不同点在于, 使用交换操作代替从 list删除数, 这样使时间复杂度降低到 O(n)

    class Solution {
        int[] arr;
        int[] origin;
        Random random = new Random();

        public Solution(int[] nums) {
            arr = nums;
            origin = nums.clone();
        }

        /**
         * Resets the array to its original configuration and return it.
         */
        public int[] reset() {
            arr = origin;
            origin = origin.clone();
            return arr;
        }

        /**
         * Returns a random shuffling of the array.
         */
        public int[] shuffle() {
            for (int i = 0; i < arr.length; i++) {
                // 生成 i-(arr.length-1)之间的随机数
                int index = random.nextInt(arr.length - i) + i;
                // 交换元素
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
            return arr;

        }
    }

参考:
官方题解