双指针问题总结

167.两数之和
题解：因为数组已按照非降序排列，所以可采用头尾双指针遍历（i为头，j为尾）。如果numbers[i] + numbers[j] > target，则大于i的其他数与numbers[j]相加都大于target，此时令j减小继续进行判断；当numbers[i] + numbers[j] < target时，比j小的其他数与numbers[i]相加均小于target，所以使i加一继续判断。代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> a;
        int i = 0, j = numbers.size() - 1;
        while(i < j)
        {
            if(numbers[i] + numbers[j] == target)
                break;
            else if(numbers[i] + numbers[j] < target)
                i++;
            else 
                j--;
        }
        a.push_back(i + 1);
        a.push_back(j + 1);
        return a;
    }
};

633.平方数之和
题解：与上题类似，本题只需寻找[0, sqrt( c )] 之间中是否存在两个数满足条件。需要注意的是由于c的范围为(0，2^31 - 1), 因此在寻找满足条件的值中会出现超出int范围的情况，因此采用long类型数据；与上一题的区别是存在相同的数相加的情况，因此循环条件有所不同。

class Solution {
public:
    bool judgeSquareSum(int c) {
        long i = 0, j = (int)sqrt(c);
        while(i <= j)
        {
            if(i * i + j * j == c)
                return true;
            else if(i * i + j*j < c)
                i++;
            else 
                j--;
        }
        return false;
    }
};

680.验证回文字符串
题解：最多删除一个字符即在前后字符出现不同时删除其中一个判断剩下的子串是否为回文。代码如下：

class Solution {
public:

    bool validPalindrome(string s) {
        int i = 0, j = s.size() - 1;
        while(i < j)
        {
            if(s[i] == s[j])
            {
                i++;
                j--;
            }
            else
                return isPalindrome(s, i+1, j) || isPalindrome(s, i, j-1);
        }
        return true;
    }
    bool isPalindrome(string& s, int i, int j)
    {
        while(i < j)
        {
            if(s[i] == s[j])
            {
                i++;
                j--;
            }
            else   
                return false;
        }
        return true;
    }
};

88.合并两个有序数组
题解：为两个数组各自设定一个指针，比较两个数组之间数的大小从而实现升序合并。

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        vector<int> temp;
        int i = 0, j = 0;
        while(i < m && j < n)
        {
            if(nums1[i] < nums2[j])
            {
                temp.push_back(nums1[i]);
                i++;
            }
            else
            {
                temp.push_back(nums2[j]);
                j++;
            }
        }
        if(i == m)	//i = m 表示nums1数组合并完毕剩下nums2数组中的数
        {
            while(j < n)
            {
                temp.push_back(nums2[j]);
                j++;
            }
        }
        if(j == n)	// i = n表示nums2数组合并完毕剩下nums1数组中的数
        {
            while(i < m)
            {
                temp.push_back(nums1[i]);
                i++;
            }
        }
        nums1.assign(temp.begin(), temp. end());
    }
};

524.通过删除字母匹配到字典里最长单词
题解：确立两个指针，一个指向s字符串，一个指向dictionary[j]，逐个遍历比较是否为s的子串，并比较是否为最长子串，记录子串的地址。代码如下：

class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        int max = 0, index = -1;
        for(int i = 0;i<dictionary.size();i++)
        {
            int x = 0, j = 0;
            while(x < s.size() && j < dictionary[i].size())
            {
                if(s[x] == dictionary[i][j])
                {
                    x++;
                    j++;
                }
                else
                    x++;
            }
            if(j == dictionary[i].size())
            {
                if(j > max)
                {
                    max = j;
                    index = i;
                }
                else if(j == max)
                {
                    if(dictionary[index] > dictionary[i])
                    {
                        index = i;
                    }
                }
            }
        }
        if(index == -1)
            return "";
        else
            return dictionary[index];
    }
};

142.环形链表||
题解：通过快慢指针寻找。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == NULL)
            return NULL;
        ListNode *slow = head, *quiet = head;
        while(1)
        {
            if(quiet->next == NULL || quiet->next->next == NULL)
                return NULL;
            slow = slow->next;
            quiet = quiet->next->next;
            if(slow == quiet)		//第一次相遇
            {
                quiet = head;
                break;
            }
        }
        while(quiet != slow)	//从头开始第二次相遇
        {
            quiet = quiet->next;
            slow = slow->next;
        }
        return quiet;
    }
};

76.最小覆盖子串
题解：采用滑动窗口的方法处理，即定义first与end指针在s字符串中滑动，使得滑动窗口中的字符包含t中字符，此时记录字符串及长度，并将first指针加一，看滑动窗口中是否缺失字符，若缺失则移动end指针补，若不缺则继续令first指针加一，从而找到最小包含t的子串。在判断滑动窗口中是否包含t中字符时，可以使用map存储t中字符出现的次数，通过遍历s，判断其是否大于0来确定是否为t中字符，并定义sum来统计s中找到与t中匹配的字符个数。同时将大于0的map值定义为需要找到的字符，小于0的定义为多余的字符。

class Solution {
public:
    string minWindow(string s, string t) {
        map<char, int> a;
        for(int i = 0;i<t.size();i++)
        {
            a[t[i]]++;
        }
        int first = 0, end = 0, min = 100001;
        int sum = 0;
        string res = "";
        while(first < s.size())
        {
            while(sum != t.size() && end < s.size())
            {
                if(a[s[end]] > 0)
                    sum++;
                a[s[end]]--;	
                end++;
            }
            if(sum != t.size() && end == s.size())	//遍历完毕无符合情况
            {
                break;
            }
            if(sum == t.size())
            {
                if(end - first < min)
                {
                    min = end - first;
                    res = s.substr(first, min);
                }
            }
            if(a[s[first]] == 0)
            {
                sum--;
            }
            a[s[first]]++;
            first++;
        }
        if(min == 100001)
        {
            return "";
        }
        else
            return res;
    }
};

340.至多包含k个不同字符的最长子串
题解：通过将end指针遍历s字符串找到k个字符所组成的字符串，然后与上题类似将first指针加一，再比较所找字符串的长度。

class Solution {
public:
    int lengthOfLongestSubstringKDistinct(string s, int k) {
		int end = 0, first = 0, max = 0;
		map<char, int> a;
		while (end < s.size())
		{
			a[s[end]] = end;
			while (a.size() > k)
			{	
				if(a[s[first]] == first)
					a.erase(s[first]);
				first++;
			}
			if(end - first + 1 > max)
			{
				max = end - first + 1;
			}
			end++;
		}
		return max;
	}
};