算法：数组常见套路1---双指针、取模、打擂台法

水深无声 2024-03-06 01:41 102阅读 0赞

![2bbbe795f3738ff13500b8f20b17ff35.png][]

### 一、数组的合并–双指针\[快慢指针\] ###

#### 1、题目： ####

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。  
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

*  注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

#### 2、分析特点： ####

**`两个数组已经被排序`**，相当于两条有序的队列，非递减，从小到大排队，每次都从两条队伍中取走最小的那个数放到结果中。

#### 3、代码： ####

public void merge(int[] nums1, int m, int[] nums2, int n) {
        
            int p1 = 0, p2 = 0;
            int[] sorted = new int[m + n];
            int cur;
            while (p1 < m || p2 < n) {
        
                if (p1 == m) {
        
                    cur = nums2[p2++];
                } else if (p2 == n) {
        
                    cur = nums1[p1++];
                } else if (nums1[p1] < nums2[p2]) {
        
                    cur = nums1[p1++];
                } else {
        
                    cur = nums2[p2++];
                }
                sorted[p1 + p2 - 1] = cur;
            }
            for (int i = 0; i != m + n; ++i) {
        
                nums1[i] = sorted[i];
            }
        }

#### 4、复杂度分析： ####

>  *  时间复杂度：O(m+n)。 指针移动单调递增，最多移动 m+n次，因此时间复杂度为 O(m+n)。
>  *  空间复杂度：O(m+n)。 需要建立长度为 m+n 的中间数组 sorted。

#### 5、总结： ####

本题比较简单，只需要抓住，有序递增的两个数组，直接当队列，抓最小。当然更简单的是直接把其中一个数组的全部元素存储到另外一个数组后面的空间，然后利用封装好的方法排序即可，即 Arrays.sort() 方法

![7a63463d895a8642c161881a263d5a32.png][]

### 二、数组的删除–双指针\[快慢指针\] ###

#### 1、题目： ####

给你一个数组 nums和一个值 val，你需要**原地移除**所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并**原地修改**输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

#### 2、分析特点： ####

*  题目要求：原地移除
 *  移除所有val的元素，则 **`结果数组一定比原数组的长度更短`**。要求原地移除 > **`我们可以把结果数组直接写在原数组上`**，并且结果数组是那些非等于val的元素组成的，从位置0开始，到某个位置作为结果数组，而原数组需要从0开始到整个数组的长度进行遍历> 使用双指针。
 *  结果数组的指针：\[0, left\]， 结果数组的目的是收集起来结果，他是left一步步进行加加的。
 *  原数组的指针：\[0, right\]，right <= 原数组长度，right 是用于指向原数组当前的元素是否不会等于val，可以被收集。

#### 3、代码： ####

public int removeElement(int[] nums, int val) {
        
            int n = nums.length;
            int left = 0;
            for (int right = 0; right < n; right++) {
        
                if (nums[right] != val) {
        
                    nums[left] = nums[right];
                    left++;
                }
            }
            return left;
        }

#### 4、复杂度分析： ####

>  *  时间复杂度：O(n)O(n)O(n)，其中 nnn 为序列的长度。我们只需要遍历该序列至多两次。
>  *  空间复杂度：O(1)O(1)O(1)。我们只需要常数的空间保存若干变量。

#### 5、总结： ####

本题比较简单，只需要抓住，题意要求：原地移除，原地==>结果只能输出到原数组上面，移除，则结果数组长度比原数组更短。利用结果数组从0，开始left++进行收集，而原数组使用right指针从0开始遍历，判断当前元素是否可以被收集起来。

==> 目的就是收集所有符合条件的元素。

![fc9f2016ffbce8365a492ab7e4bf210f.png][]

### 三、数组的轮询–取模 ###

#### 1、题目： ####

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

#### 2、分析特点： ####

*  `轮转 ==> 取模运算`
 *  我们可以使用额外的数组来将每个元素放至正确的位置。用 n 表示数组的长度，我们遍历原数组，将原数组下标为 i 的元素放至新数组下标为 (i+k) mod n 的位置，最后将新数组拷贝至原数组即可。

#### 3、代码： ####

public void rotate(int[] nums, int k) {
        
            int n = nums.length;
            int[] newArr = new int[n];
            for (int i = 0; i < n; ++i) {
        
                newArr[(i + k) % n] = nums[i];
            }
            System.arraycopy(newArr, 0, nums, 0, n);
        }

#### 4、复杂度分析： ####

>  *  时间复杂度： O(n)，其中 n 为数组的长度。
>  *  空间复杂度： O(n)。

#### 5、总结： ####

轮转、循环 k 步，要想到取模运算，另外需要一个新数组作为结果数组是因为如果我们不使用额外数组，我们直接将每个数字放至它最后的位置，这样被放置位置的元素会被覆盖从而丢失，所以需要一个新数组作为结果数组，最后拷贝回去原数组。

![ca3caacce3c0d8a0195d5ea88c6b7f24.png][]

### 四、数组的最大差值–打擂台法 ###

#### 1、题目： ####

给定一个整数数组 nums，找出给定数组中两个数字之间的最大差值。要求，第二个数字必须大于第一个数字。

#### 2、分析特点： ####

*  **`求最大差值 ==> 最大值 - 最小值`**
 *  只需要遍历价格数组一遍，记录历史最小值，非最小值的考虑是最大值。

#### 3、代码： ####

public int maxProfit(int nums[]) {
        
            int minNum = Integer.MAX_VALUE;
            int maxNum = 0;
            for (int i = 0; i < nums.length; i++) {
        
                if (nums[i] < minNum) {
        
                    minNum = nums[i];
                } else if (nums[i] - minNum > maxNum) {
        
                    maxNum = nums[i] - minNum;
                }
            }
            return maxNum;
        }

#### 4、复杂度分析： ####

>  *  时间复杂度：O(n)，只需要遍历一次。
>  *  空间复杂度：O(1)，只使用了常数个变量。

#### 5、总结： ####

使用打擂台的思想，遍历的时候，考虑当前值是最小值，则记录最小值，否则考虑当前值是最大值，进行更新。

**如果本文对你有帮助的话记得给一乐点个赞哦，感谢！**

[2bbbe795f3738ff13500b8f20b17ff35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/06/1c158586d4f54f8183877d38838e62fa.png
[7a63463d895a8642c161881a263d5a32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/06/3fac58f6306541d4a34d290c0622afb3.png
[fc9f2016ffbce8365a492ab7e4bf210f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/06/7596eeefc08f4a69b33fbca4a50abf8a.png
[ca3caacce3c0d8a0195d5ea88c6b7f24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/06/bc7df16a781142e2bf26248781943b44.png