leetcode刷题篇---双指针

1、有序数组的 Two Sum：在有序数组中找出两个数，使它们的和为 target

这个首先它的前提是有序数组，因此可以使用双指针结合二分查找的方式来进行，一个指针指向值比较小的，从头向尾移动，一个指针指向值比较大的，从尾向头移动，则可得：
（1）如果两者相加结果sum==target，就得到想要的结果；
（2）如果两者相加结果sum （3）如果两者相加结果sum>target，则将指向值比较大的指针向前移动；
实现代码：

vector twoSum(vector& numbers, int target) {
        vector result;
        if(numbers.empty())
            return result;
        int begin=0;
        int end=numbers.size()-1;
        while(begin

2、平方数之和：给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a^2 + b ^2 = c

这个题和第一题类似，其实就是采用双指针法，begin指针从0开始向后遍历，end指针从sqrt（c）开始向前遍历，0到sqrt（c）就是一个有序的数组，sum=beginbegin+endend，如果sumtarget，end–,如果sumtarget，返回true；直到begin>end跳出循环（注意beginend也可以执行循环，比如target为2的情况，他就是2=11+11）
实现代码：

bool judgeSquareSum(int c) {
        if(c<0)
            return false;
        long begin=0;
        long end=(long)sqrt(c);
        while(begin<=end)
        {
            long sum=begin*begin+end*end;
            if(sum==c)
                return true;
            else if(sum

3、反转字符串中的元音字母，例如leetcode反转后为leotcede

首先实现一个函数判断元音字符，然后反转字符就是将前面的字符和后面的字符进行交换，因此可以使用双指针法，begin从0开始向后遍历，end从s.size()向前遍历，如果begin和end所在的字符都是元音字符，交换，继续遍历直到begin==end，实现代码：

bool isorigin(char ch)
 {
     if(ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u' || ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U')
         return true;
     else
         return false;
 }
string reverseVowels(string s) {
        if(s.empty())
            return s;
        int begin=0;
        int end=s.size();
        while(begin

4、验证回文串：给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

我们知道，验证回文串十分简单，只需要一个指针从头遍历，一个指针从尾向前遍历，在循环结束之前两个元素一旦不同就不是回文串，否则循环结束，说明是回文串，但是这里又增加了一个条件，也就是如果遍历到两个元素不同时，其实可以删除两者中的一个元素，看其能否成为回文串，其实也就是删除左边指针所在的元素或者删除右边指针所在的元素即可，实现代码：

bool Palindrome(string s,int i,int j)//判断回文
    {
        while(i

5、合并两个有序的数组：给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组

这个问题是不需要额外去开辟空间来保存结果，而是合并到nums1中去，因此我们必须从后向前遍历，使用两个指针，一个在nums1从后向前遍历，一个在nums2从后向前遍历，如果nums1为空，直接将nums2的元素依次赋给nums1，如果nums2为空，直接将nums2的元素依次赋给nums1，分别遍历这两个数组，进行合并，实现代码：

void merge(vector& nums1, int m, vector& nums2, int n)
{
	int p1 = m - 1;
	int p2 = n - 1;
	int index = m + n - 1;
	while (p1 >= 0 || p2 >= 0)
	{
		if (p1 < 0)
			nums1[index--] = nums2[p2--];
		else if (p2 < 0)
			nums1[index--] = nums1[p1--];
		else if (nums1[p1]>nums2[p2])
			nums1[index--] = nums1[p1--];
		else
			nums1[index--] = nums2[p2--];
	}
}

6、判断链表是否带环

其实这个问题就跟运动员赛跑一样，如果是直形跑道，跑的快的就永远不会跟跑的慢的相遇，但是如果是环形跑道，，快的运动员在多于慢的一圈时，就会相遇，因此我们这里运用快慢指针，快指针一次走两步，慢指针一次走一步，如果中间相遇，说明带环，如果快指针走到nullptr或者快指针的next是nullptr，还没有相遇，说明没有环，实现代码：

bool hasCycle(ListNode *head) 
{
	   if(head==nullptr)
            return false;
        ListNode* fast=head;
        ListNode* slow=head;
        //使用快慢指针
        while(fast!=nullptr && fast->next!=nullptr)
        {
            fast=fast->next->next;//快指针每次走两步
            slow=slow->next;//慢指针走一步
            //如果相遇，说明带环
            if(fast==slow)
                return true;
        }
        return false;   
 }

7、
Input:
s = “abpcplea”, d = [“ale”,“apple”,“monkey”,“plea”]
Output:
“apple”
删除 s 中的一些字符，使得它构成字符串列表 d 中的一个字符串，找出能构成的最长字符串。如果有多个相同长度的结果，返回字典序的最小字符串

这里我们可以认为d中的某个字符串是s的子序列，先实现一个判断子序列的函数isSubstr，即判断t是否是s的子序列，使用双指针，一个遍历s，一个遍历t，如果s[i]==t[j]，则j继续在t中向后走一步，i也继续在s中向后走一步，如果不相等，则只需要i在s中向后走一步，继续循环

bool isSubstr(string s,string t)//判断t字符串是否是s的子序列
    {
        int i=0;//用来遍历s
        int j=0;//用来遍历t
        while(i& d) 
{
	 string result="";//结果字符串
        for(int i=0;id[i].size() || (result.size()==d[i].size() && result.compare(d[i])<0))
                continue;
            if(isSubstr(s,d[i]))//如果符合子序列要求
                result=d[i];
        }
        return result;
}