题目：轮转数组

原题链接：轮转数组

方法1-使用额外的数组

方法1是自己写出来的。方法2参考的别人的，方法2太👍了，不易发现这个规律

    public static void rotate(int[] nums, int k) {
        int[] temp = new int[nums.length];
        int j = 0;
        k = k % nums.length; // 数组长度大于k时，旋转次数取余---关键
        for (int i = nums.length - k; i < nums.length; i++) {
            temp[j++] = nums[i];
        }
        for (int i = 0; i < nums.length - k; i++) {
            temp[j++] = nums[i];
        }
        System.arraycopy(temp, 0, nums, 0, nums.length);
    }

方法2-三次反转数组

    private static void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }

    public static void rotate1(int[] nums, int k) {
        k = k % nums.length;  
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

除自身以外数组的乘积

原题链接：除自身以外数组的乘积

方法1-用到了除法

当时没看题目中不让用除法，当时一下就想到这个思路了，哈哈哈

    public static int[] productExceptSelf(int[] nums) {
        int temp = 1;
        int zero = 0;
        // 先看数组中0的个数  大于1则结果数组全为0  等于1则结果数组中0的位置为其他元素乘积
        for (int num : nums) {
            if (num != 0) {
                temp *= num;
            } else {
                zero++;
                if (zero > 1) return new int[nums.length];
            }
        }
        List<Integer> res = new ArrayList<>();
        for (int num : nums) {
            if (zero == 1) {
                //num==0 则当前结果数组该位置的结果为其他元素乘积
                res.add(num == 0 ? temp : 0);
            } else {
                res.add(temp / num);
            }
        }
        return res.stream().mapToInt(Integer::intValue).toArray();
    }

方法2-前后缀乘积法

方法2使用两次遍历分别计算数组元素左边和右边的乘积，从而构建出结果数组

    public static int[] productExceptSelf1(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];

        // 第一次遍历，计算左边所有元素的乘积
        res[0] = 1;
        for (int i = 1; i < n; i++) {
            res[i] = res[i - 1] * nums[i - 1];
        }
        // 第二次遍历，计算右边所有元素的乘积，并更新结果数组
        int right = 1;
        for (int i = n - 1; i >= 0; i--) {
            res[i] *= right; //res[i]是当前i左边元素全部乘积
            right *= nums[i]; //用一个变量记录当前元素右边的所有元素乘积
        }
        return res;
    }

---

❤觉得有用的可以留个关注ya~❤