「数组」数组双指针算法合集:二路合并|逆向合并|快慢去重|对撞指针 / LeetCode 88|26|11(C++)

目录

概述

1.二路合并

思路

复杂度

Code

2.逆向合并

思路

复杂度

Code

3.快慢去重

思路

复杂度

Code

4.对撞指针

思路

复杂度

Code

总结


概述

数组的线性枚举是我们学习编程时遇到的第一种枚举手段。但是它看起来有点愚蠢:只有一个索引i承担全部的工作,如果有第二个索引j,它总是被嵌套在一次for循环的内部。

像这样:

for (int i = 0;i < n;i++){
   for(int j = i;j < n;j++)
      ...
}

这种行为看起来很直观,但是使得这段代码的复杂度达到了O(n²) 。

但如果我们这样做呢?

for (int i = 0,j = 0;i < n;i++){
   ...
}

在一次循环内维护两个下标索引的行为叫做双指针,如你所见, 这一层for循环的时间复杂度是线性的。

来看看它具体是怎么用的。


1.二路合并

思路

二路合并就是将两个有序数组合成一个有序数组。

我们希望将两个指针指向了两个有序数组,只遍历一次就能够完成合并操作。尽管很简单,但这是归并排序的核心操作之一。

事实上,我们需要三个指针:i,j,k。各自指向两个待合并数组nums1、nums2和承载结果的数组ans。

如果nums1[i]<nums2[j]令承载结果的数组ans[k]获得nums1[i]元素,然后i和k后移一位。

否则ans[k]获得nums2[j]元素,然后j和k后移一位。

你会注意到:每轮循环后i和j分别指向两个数组中的待比较的元素,k指向ans数组的待写入位置

当i或j到达末尾时,将另一方的剩余元素写入ans中。 

复杂度

时间复杂度:O(m+n)

空间复杂度:O(m+n)

m、n:两个数组各自长度

Code

vector<int> merge(vector<int>&a,vector<int>&b){
	const int n=a.size(),m=b.size();
	vector<int>ans(n+m);
	int i=0,j=0,k=0;
	while(i<n&&j<m){
		if(a[i]<b[j])ans[k++]=a[i++];
		else ans[k++]=b[j++];
	}
	while(i<n)ans[k++]=a[i++];
	while(j<m)ans[k++]=b[j++];
	return ans;
}

2.逆向合并

在二路合并中,如果没有承接数组ans怎么办?

LeetCode 88:

给定两个排序后的数组 A 和 B,其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法,将 B 合并入 A 并排序。

初始化 A 和 B 的元素数量分别为 m 和 n

示例 :

输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出:[1,2,2,3,5,6]
解释:需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ,其中斜体加粗标注的为 nums1 中的元素。

思路

但是我们有一个容量很大的A数组。

考虑这样一个问题:A的后面总是能容纳B,所以我们可以对整个合并操作进行逆向调整,也就是从A末尾的空白区域开始写入元素。

如果你写入了A的元素,那么这意味着前面有一个A元素已经失效了,它被转移到了A末尾,在A的前面删掉一个元素,再在末尾加回来,那么A的空余区不变,仍能容纳B。

如果你写入了B的元素,那么占用一格A的空余区。但是A的空余区只在B完全写入时才被填满。

复杂度

时间复杂度:O(m+n)

空间复杂度:O(1)

Code

void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
    int i=m-1,j=n-1,k=n+m-1;
    while(i>=0&&j>=0){
        if(nums1[i]<nums2[j])nums1[k--]=nums2[j--];
        else nums1[k--]=nums1[i--];
    }
    while(i>=0)nums1[k--]=nums1[i--];
    while(j>=0)nums1[k--]=nums2[j--];
}

3.快慢去重

LeetCode 26:

给你一个 非严格递增排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ,你需要做以下事情:

  • 更改数组 nums ,使 nums 的前 k 个元素包含唯一元素,并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
  • 返回 k 。

思路

C++标准库在algorithm库下定义了unique函数,实现了这个功能。我们来想一想该怎么实现它。

这种算法必须基于已排序数组实现。 

定义快指针fast向后探索,慢指针slow维护去重区。 

事实上,我们只依靠fast指针来遍历数组,slow做的工作并不是遍历而是维护fast指针探索的结果。

slow总是指向去重区后的第一个待写入位置,slow-1则为去重区的最后一个位置。

每次都依靠fast指针与slow-1进行比对,然后将可行元素写入slow位置处,随后slow++。

注意要从下标1开始。

复杂度

时间复杂度:O(n)

空间复杂度:O(1)

Code

int removeDuplicates(vector<int>& nums) {
    const int n=nums.size();
    int slow=1,fast=1;
    for(;fast<n;fast++)
       if(nums[fast]!=nums[slow-1])
         nums[slow++]=nums[fast];
    return slow;
}

4.对撞指针

LeetCode 11:

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

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

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

说明:你不能倾斜容器。

示例 :

d63975869651051e4be5f94a25193e73.jpeg

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

思路

对撞指针从两个方向同时遍历数组。

定义i=0,j=n-1;分别从两侧向内收缩。

双向遍历往往只收缩i和j的其中一个指针,这意味着我们需要知道i右移和j左移的条件。

我们认识到这样一个问题:遍历时容器底的长度总是减小的。因此,如果希望收缩双指针时容量还能增大,那么必须是指针元素小的一方收缩:容器容量总是由他的短边决定。

复杂度

时间复杂度:O(n)

空间复杂度:O(1)

Code

int maxArea(vector<int>& height) {
    int len=height.size();
    int ans=(len-1)*min(height[0],height[len-1]);
    for(int i=0,j=len-1;i<j;){
       int V=(j-i)*min(height[j],height[i]);
       if(V>ans)ans=V;
       if(height[j]>height[i])i++;
       else j--;
    }
    return ans;
}

总结

双指针是一种简单而又灵活的技巧和思想,单独使用可以轻松解决一些特定问题,和其他算法结合也能发挥多样的用处。

我们后续将讲解滑动窗口思想,他也是一类双指针问题。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值