leetcode-数组

yeye19891224

已于 2024-01-08 23:13:34 修改

阅读量1.6k

点赞数 44

分类专栏： leetcode 算法文章标签： leetcode 算法 java

于 2024-01-06 22:12:20 首次发布

本文链接：https://blog.csdn.net/zhouweiye2012/article/details/135424602

版权

算法同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

leetcode

1 篇文章 0 订阅

订阅专栏

二、container-with-most-water

一、move-zeroes

1.题目描述

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作

2.示例

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

3.提示

1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

4.题解

方法一

思路

第一次循环将数组索引值不为零的数据和数组index交换，这样保证不为零的数据都被交换到前排，循环结束，index之后的数据代表被交换过的数据，所以第二次循环将index后的数据置为零。

代码

public void moveZeroes(int[] nums) {
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (0 != nums[i]) {
            nums[index] = nums[i];
            index++;
        } else {
            continue;
        }
    }
    for (int i = index; i < nums.length; i++) {
        nums[i] = 0;
    }
}

方法二

思路

双指针同向，一次循环,双指针同时指向数组头部，右指针先行，判断不为0交换左指针数据，为0指针向右移动。

注意：不能直接讲右指针数据置为0，而是要与左指针数据交换，因为数组可能只有一个值。

代码

public void moveZeroes(int[] nums) {
    int n = nums.length, left = 0, right = 0;
    while (right < n) {
        if (nums[right] !=0 ) {
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++;
        }
        right++;
    }
}

二、container-with-most-water

1.题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

2.示例

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

3.提示

n == height.length
2 <= n <= 105
0 <= height[i] <= 104

`4.题解`

`方法`

`思路`

双指针对向，向中间移动，计算区间面，之后移动高度相对较小边的指针，注意方法中访问了元素，避免数组越界，right = hight.length - 1。

`代码`

public int maxArea(int[] height) {
    int maxArea = 0;
    int left = 0;
    int right = height.length -1;
    while (left < right) {
        int area = (right - left) * Math.min(height[left], height[right]);
        maxArea = Math.max(maxArea, area);
        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }
    return maxArea;
}

三、climbing-stairs

1.题目描述

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

2.示例

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

3.提示

1 <= n <= 45

`4.题解`

方法

思路

斐波那契数列，第一个台阶有1种走法，第二个台阶有2种走法，第三个台阶有3种走法。

爬第n阶楼梯的方法数量，等于爬上 n−1 阶楼梯的方法数量 + 爬上 n−2阶楼梯的方法数量。

动态规划解析：
状态定义：设 dp 为一维数组，其中 dp[i] 的值代表斐波那契数列的第 ii个数字。
转移方程： dp[i+1]=dp[i]+dp[i−1]，即对应数列定义 f(n+1)=f(n)+f(n−1)。
初始状态： dp[0]=1, dp[1]=1 ，即初始化前两个数字。
返回值： dp[n] ，即斐波那契数列的第 n 个数字。

代码

 public int climbStairs(int n) {
    int[] dp = new int[n+1];
    dp[0] = 1;
    dp[1] = 1;
    for (int i = 2; i<= n; i++) {
        dp[i] = dp [i-1] + dp[i-2];
    }
    return dp [n];
}

四、3sum

1.题目描述

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

2.示例

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

3.提示

3 <= nums.length <= 3000
-105 <= nums[i] <= 105

4.题解

方法

思路

先排序，固定第一个数，在与后两个数相加，大于零右指针左移，小于零左指针右移，等于零为解，并且判断左右指针是否与left+1，right-1相等，如果相等跳过重复。

代码

public List<List<Integer>> threeSum(int[] nums) {
    List<List<Integer>> ans = new ArrayList();
    int len = nums.length;
    if (nums.length < 3) return ans;
    Arrays.sort(nums);
    for (int i = 0; i< len;i++) {
        if (nums[i] > 0) break;

        if (i >0 && nums[i] == nums[i-1]) continue;
        if (i > (len -3)) return ans;
        int left = i + 1;
        int right = len-1;
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0){
                ans.add(Arrays.asList(nums[i],nums[left],nums[right]));
                
                while(left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum > 0 ) {
                right--;
            } else if(sum < 0) {
                left++;
            }
        }
    }
    return ans;
}

六、4sum

1.题目描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案。

2.示例

示例 1：

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

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

3.提示

1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

`4.题解`

`方法`

`思路`

和三数和相似，多一重循环。

时间复杂度 O(n^3)，其中 n 是数组的长度。排序的时间复杂度是 O(nlog⁡n)，枚举四元组的时间复杂度是 O(n^3)，因此总时间复杂度为 O(n3+nlogn)=O(n3)。

`代码`

 List<List<Integer>> quadruplets = new ArrayList<List<Integer>>();
    if (nums == null || nums.length < 4) {
        return quadruplets;
    }
    Arrays.sort(nums);
    int length = nums.length;
    for (int i = 0; i < length - 3; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) {
            continue;
        }
        if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
            break;
        }
        if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
            continue;
        }
        for (int j = i + 1; j < length - 2; j++) {
            if (j > i + 1 && nums[j] == nums[j - 1]) {
                continue;
            }
            if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                break;
            }
            if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            int left = j + 1, right = length - 1;
            while (left < right) {
                long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                if (sum == target) {
                    quadruplets.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    left++;
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    right--;
                } else if (sum < target) {
                    left++;
                } else {
                    right--;
                }
            }
        }
    }
    return quadruplets;
}