二、数组（剑指）

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量73 收藏
点赞数
文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsdxph/article/details/131284222
版权

数组

1 基础知识

空间效率不一定高：
即使只存储一个元素，也需要按照定义位所有数据预先分配内存。
于是出现了动态数组ArrayList

2 双指针

两端向中间走：
求排序数组中的两个数字之和。
同向双指针：
求正数数组中子数组的和或乘积。

面试题6：排序数组中的两个数字之和

/**给定一个已按照 升序排列  的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 0 开始计数 ，所以答案数组应当满足 0 <= answer[0] < answer[1] < numbers.length 。

假设数组中存在且只存在一对符合条件的数字，同时一个数字不能使用两次。

 

示例 1：

输入：numbers = [1,2,4,6,10], target = 8
输出：[1,3]
解释：2 与 6 之和等于目标数 8 。因此 index1 = 1, index2 = 3 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[0,2]
示例 3：

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

提示：

2 <= numbers.length <= 3 * 104
-1000 <= numbers[i] <= 1000
numbers 按 非递减顺序 排列
-1000 <= target <= 1000
仅存在一个有效答案
*/
class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i = 0;
        int j = numbers.length - 1;
        while (i < j && numbers[i] + numbers[j] != target) {
            if (numbers[i] + numbers[j] < target) {
                i++;
            } else {
                j--;
            }
        }
        return new int[]{i, j};
    }
}

面试题7：数组中和为0的3个数字

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

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

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

 

 

示例 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 。
*/
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) continue;
            int target = -nums[i];
            int start = i + 1;
            int end = nums.length - 1;
            while (start < end) {
                if (nums[start] + nums[end] == target) {
                    var result = new ArrayList<Integer>();
                    result.add(-target);
                    result.add(nums[start]);
                    result.add(nums[end]);
                    results.add(result);
                    start++;
                    end--;
                    while (start < nums.length && nums[start] == nums[start - 1]) start++;
                    while (end > 0 && nums[end] == nums[end + 1]) end--;
                } else if (nums[start] + nums[end] < target) {
                    start++;
                    while (start < nums.length && nums[start] == nums[start - 1]) start++;
                } else {
                    end--;
                    while (end > 0 && nums[end] == nums[end + 1]) end--;
                }
            }
        }
        return results;
    }
}

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            int j = i + 1;
            int k = nums.length - 1;
            while (j < k) {
                if (nums[j] + nums[k] == -nums[i]) {
                    ArrayList<Integer> list = new ArrayList<>();
                    list.addAll(List.of(nums[i], nums[j], nums[k]));
                    result.add(list);
                    j++;
                    while (j < nums.length - 1 && nums[j] == nums[j - 1]) {
                        j++;
                    }
                } else if (nums[j] + nums[k] < -nums[i]) {
                    j++;
                } else {
                    k--;
                }
            }
        }
  
        return result;
    }
}

面试题8：和大于或等于k的最短子数组

/**给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

 

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：

输入：target = 4, nums = [1,4,4]
输出：1
示例 3：

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

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

*/
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int minLength = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (left <= right && sum >= target) {
                minLength = Math.min(minLength, right - left + 1);
                sum -= nums[left++];
            }
        }
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
}

面试题9：乘积小于k的子数组

/**给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。

 

示例 1:

输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8 个乘积小于 100 的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
示例 2:

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

提示: 

1 <= nums.length <= 3 * 104
1 <= nums[i] <= 1000
0 <= k <= 106
 

*/
class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        int left = 0;
        int count = 0;
        long product = 1;
        for (int right = 0; right < nums.length; right++) {
            product *= nums[right];
            while (left <= right && product >= k) {
                product /= nums[left++];
            }
            count += right >= left ?  right -left + 1 : 0;
        }
        return count;
    }
}

3 累加数组数字求子数组之和

双指针解决子数组之和前提：数组中的所有数字都是正数。
因为如果有负数，增加一个数字不一定能增加子数组之和，删除一个数字也不一定能减少子数组之和。
累加数组数字求子数组之和：
在数组[1,2,3,4,5,6]中，从下标0开始到下标2结束的子数组之和是6，从下标0到下标4的子数组这和为15，则从下标3到下标4的子数组之和为15-9= 6；

面试题10：和为k的子数组

给定一个整数数组和一个整数 k ，请找到该数组中和为 k 的连续子数组的个数。

 

示例 1：

输入:nums = [1,1,1], k = 2
输出: 2
解释: 此题 [1,1] 与 [1,1] 为两种不同的情况
示例 2：

输入:nums = [1,2,3], k = 3
输出: 2
 

提示:

1 <= nums.length <= 2 * 104
-1000 <= nums[i] <= 1000
-107 <= k <= 107

如果给定数组都为正数：

class Solution {
    public int subarraySum(int[] nums, int k) {
        int left = 0;
        int sum = 0;
        int count = 0;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (left <= right && sum > k) {
                sum -= nums[left++];
            }
            if (left <= right && sum == k) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        var test = new int[]{1,2,3,4,5};
        System.out.println(solution.subarraySum(test, 9));
    }
}

如果不确定正负：

class Solution {
    public int subarraySum(int[] nums, int k) {
        // 前i个数字之和，以及这个和的出现次数
        var sumToCount = new HashMap<Integer, Integer>();
        sumToCount.put(0, 1);
        int sum = 0;
        int count = 0;
        for (int num : nums) {
            sum += num;
            count += sumToCount.getOrDefault(sum - k, 0);
            sumToCount.merge(sum, 1, Integer::sum);
        }
        return count;
    }
}

思路：
从头到尾扫描数组中的数字时求出前i个数字之和，并将和保存下来(sum)。哈希表的键是前i个数字之和，值为这个和在截止到目前扫描为止出现的次数。

面试题11：0和1个数相同的子数组

给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。

 

示例 1：

输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。
示例 2：

输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量 0 和 1 的最长连续子数组。
 

提示：

1 <= nums.length <= 105
nums[i] 不是 0 就是 1


class Solution {
    public int findMaxLength(int[] nums) {
        var sumToIndex = new HashMap<Integer, Integer>();
        sumToIndex.put(0, -1);
        int sum = 0;
        int maxLength = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i] == 0 ? -1 : 1;
            if (sumToIndex.containsKey(sum)) {
                maxLength = Math.max(maxLength, i - sumToIndex.get(sum));
            } else {
                // 第一次出现的数字和的下标--最长长度。
                sumToIndex.put(sum, i);
            }
        }
        return maxLength;
    }
}

思路：
将0改为-1，类似于面试题10。
和为k的子数组个数。
和为k的最长子数组。

面试题12：左右两边子数组的和相等

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

 

示例 1：

输入：nums = [1,7,3,6,5,6]
输出：3
解释：
中心下标是 3 。
左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ，
右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。
示例 2：

输入：nums = [1, 2, 3]
输出：-1
解释：
数组中不存在满足此条件的中心下标。
示例 3：

输入：nums = [2, 1, -1]
输出：0
解释：
中心下标是 0 。
左侧数之和 sum = 0 ，（下标 0 左侧不存在元素），
右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。
 

提示：

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

class Solution {
    public int pivotIndex(int[] nums) {
        int leftSum = 0;
        int rightSum = 0;
        for (int num : nums) {
            rightSum += num;
        }
        for (int i = 0; i < nums.length; i++) {
            rightSum -= nums[i];
            if (i != 0) {
                leftSum += nums[i - 1];
            }
            if (leftSum == rightSum) {
                return i;
            }
        }
        return -1;
    }
}

class Solution {
    public int pivotIndex(int[] nums) {
        int total = 0;
        for (int num : nums) {
            total += num;
        }
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if (sum - nums[i] == total - sum) {
                return i;
            }
        }
        return -1;
    }
}

面试题13：二维子矩阵的数字之和

给定一个二维矩阵 matrix，以下类型的多个请求：

计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。
实现 NumMatrix 类：

NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化
int sumRegion(int row1, int col1, int row2, int col2) 返回左上角 (row1, col1) 、右下角 (row2, col2) 的子矩阵的元素总和。

示例 1：
在这里插入图片描述

输入:
[“NumMatrix”,“sumRegion”,“sumRegion”,“sumRegion”]
[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]
输出:
[null, 8, 11, 12]

解释:
NumMatrix numMatrix = new NumMatrix([[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]]);
numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和)
numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和)
numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和)

class NumMatrix {

    private int[][] sums;

    public NumMatrix(int[][] matrix) {
        if (matrix.length == 0 || matrix[0].length == 0) {
            return;
        }
        sums = new int[matrix.length + 1][matrix[0].length + 1];
        for (int i = 0; i < matrix.length; i++) {
            int rowSum = 0;
            for (int j = 0; j < matrix[0].length; j++) {
                rowSum += matrix[i][j];
                sums[i + 1][j + 1] = sums[i][j + 1] + rowSum;
            }
        }
    }

    public int sumRegion(int row1, int col1, int row2, int col2) {
        return sums[row2 + 1][col2 + 1] - sums[row1][col2 + 1]
                - sums[row2 + 1][col1] + sums[row1][col1];
    }
}
吃菜像吃草
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
剑指offer 66 构建乘积数组
Ding_xiaofei的博客
07-29 442
题目描述 给定一个数组 A[0, 1,…, n-1], 请构建一个数组 B[0, 1,…, n-1], 其中 B 中的元素 B[i]=A[0]A[1]…A[i-1]*A[i+1]…*A[n-1]。不能使用除法。 public int[] multiply(int[] A) { int n = A.length; int[] B = new int[n];...
剑指offer-查找旋转数组的最小数
vic_blackRabbit的博客
07-16 188
题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 思路：二分查找 （1）若只有小半的数字被旋转过去，则中间数位于前半部的非递减数组内，此时中间数>=左边>...
剑指offer - 旋转数组
夏尔的小木屋
07-06 172
数组的旋转，例如 {3,4,5,1,2}为{1,2,3,4,5}的一个旋转
剑指Offer——二维数组中的查找
KeepUP
04-08 218
题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 时间限制：1秒 空间限制：32768K 本题知识点： 查找 代码实现 public class Solution { public boolean Find(int target, int...
剑指offer-10 旋转数组
每天进步一点点！
06-29 533
题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 思路： 采用二分法解答这个问题， mid = low + (high - low)/2 需要考虑
剑指offer- 旋转数组的最小元素
前端产品工程师
10-28 518
一、问题描述 时间限制：1秒空间限制：32768K 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 二、 思路 采用三个指针，其中一个前一个后，一个在中间
剑指Offer：二维数组查找
带翅膀的猫的博客
01-19 3833
存在这样的一个二维数组，它的每一行都按照从左至右的递增顺序排序，每一列都按照从上至下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 示例： 在此二维数组中查找数字7，查找成功返回true；在此数组中查找数字5，查找失败返回false。 如果你说遍历数组那就没意思了，这也谈不上什么好方法。必挂你！！ 算法思路
剑指offer_旋转数组
刘同学的博客
11-16 221
0. 题目 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 1.解题方式1 利用STL中 algorithm库 sort 函数 1.1 相关sort函数说明 sort...
剑指offer——二维数组中的查找
xy的博客
03-19 822
在一个二维数组中，每一行都按照从左到右的顺序递增排序，每一列都按照从上到下的顺序递增排序，在这个数组中查找一个数字，如果找到了，返回true，如果未找到，返回false。 例如： 数组如下： 1 2 8 9 2 4 9 12 4 7 10 13 6 8 11 15在解决这个问题时，首先想到最简单，最直接的方法，就是从上到下依次搜索，直到找到要查找的数字，或者查找完所有
剑指Offer 04 二维数组中的查找（python）
axiongqiang的博客
04-22 289
题目描述：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路：首先选取数组中右上角的数字。如果该数字等于要查找的数字，查找过程结束；如果该数字大于要查找的数组，行下标减1；如果该数字小于要查找的数字，列下标加一。直到找到要查找的数字，或者查找范围为空。 示例1: 输...
Python《剑指offer》算法实现-二维数组查找
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
剑指offer之 旋转数组的最小数字
01-20
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给...
《剑指Offer》系列一——二维数组中的查找
12-21
《剑指Offer》是一本著名的编程面试准备书籍，其中涵盖了各种算法和数据结构的实战题目。本篇讨论的是该书中的第一道题目，即“二维数组中的查找”。 题目要求在一个特殊的二维数组中查找特定整数是否存在。这个二...
（一）剑指offer—Python版—数组篇
12-21
本篇内容主要围绕《剑指Offer》书中关于数组的经典问题进行讲解，涵盖多个与数组处理相关的算法题目。 1. **二维数组中的查找** 在一个每行按从左到右递增、每列按从上到下递增排列的二维数组中，我们需要编写一个...
剑指offer之C语言不修改数组找出重复的数字
01-20
在一个长度为N+1的数组里面的所有数字都在范围1~N范围内，所以数组至少有一个数字是重复的，请找出重复数字，但是不能修改输入的数组。 2 思路 思路1： 我们开辟一个新的数组，初始化为0，然后把原始数组每个数据的...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 916
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 226
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 212
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 292
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
剑指Offer：数组与二维数组问题解法
在《力扣剑指Offer》这本书中，提供了几个有趣的编程题目来帮助读者提升算法技能和理解。以下是针对三个具体问题的详细解析： 1. **数组中重复的数字** 题目要求找出一个整数数组中重复出现的数字。`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值