数据结构刷题之【双指针】

一、概念

所谓双指针，指的是遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个方向相同或相反的指针进行扫描，从而达到相应的目的。注：这里的指针不是指c中指针的概念，而是指一种索引。

二、例题，用于日后复习刷题

1. 给定一个有序递增数组，在数组中找到满足条件的两个数，使得这两个数的和为某一给定的值，如果有多对数，只需输出一对即可。leecode链接

#include <stdio.h>
 
int getThePair(int *a,int n,int theNum,int &left,int &right){
	int start = 0,end = n-1;
	while(start < end){
		int sum = a[start] + a[end];
		if(sum == theNum){
			left = a[start];
			right = a[end];
			return 1;
		}
		if(sum < theNum){
			start ++;
		}else if(sum > theNum){
			end --;
		}
	}
	return 0;
}
 
int main(){
 	int a[] = {1,2,3,4,5,6,7,8};
 	int start = 0,end = 0;
 	for(int i = 1; i <= 16; i++){
 		if(getThePair(a,8,i,start,end)){
 			printf("the sum of %d is %d + %d\n",i,start,end);
		}else{
			printf("sorry,%d not found~~\n",i);
		}
	}
	return 0;
}

2. 奇偶排序。给定一个数组，元素有奇数有偶数。要求对数组进行处理，使得数组的左边为奇数，右边为偶数。905-leecode链接

void partition(int *arr,int n){
	int i = 0;
	int j = n-1;
        while(1){
            while(i<j && arr[i]%2 == 1) i++;
	        while(i<j && arr[j]%2 == 0) j--;
	        if(i<j){
	            int temp = arr[i];
	            arr[i] = arr[j];
	            arr[j] = temp;
	        }
        }
 }

3. 求单链表的中间元素。给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。876-leecode链接

/*
 * 取单链表的中间元素，如果单链表元素为奇数个，那么去中间的元素，如果是偶数个，取后面的一个元素。
 */ 
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        if(head->next==nullptr){return head;}
        ListNode* p=new ListNode();
        ListNode* q=new ListNode();

        p=head->next;
        q=head->next;
        while(q->next!=nullptr){
            if(q->next->next!=nullptr){
                q=q->next->next;
                p=p->next;
            }else{
                return p;
            }
        }
        return p;
    }
};

4. 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。11-leecode链接

class Solution {
public:
    int maxArea(vector<int>& height) {
        int i = 0, j = height.size() - 1, res = 0;
        while(i < j) {
            res = height[i] < height[j] ? 
                max(res, (j - i) * height[i++]): 
                max(res, (j - i) * height[j--]); 
        }
        return res;
    }
};