2019-02-22 LintCode刷题总结之双指针算法

Two Sum

实际上正规的教科书上并没有双指针这种算法，只不过在做题的过程中我们总结出了一大类问题，可以通过两根指针来解决，这类问题最经典的要属56. 两数之和。这是一个最经典的问题，大家可能都有遇到过，由此引申出57. 三数之和和58. 四数之和，两数和的问题可以通过更简单的哈希表方法去做，所以我们来看一下三数和的解法，代码如下。

class Solution {
public:
    /**
     * @param numbers: Give an array numbers of n integer
     * @return: Find all unique triplets in the array which gives the sum of zero.
     */
    vector> threeSum(vector &numbers) {
        // write your code here
        if (numbers.size() < 3) {
            return {};
        }
        
        vector > res;
        sort(numbers.begin(), numbers.end());
        
        for (int i = 0; i < numbers.size(); ++i) {
            if (i && numbers[i] == numbers[i - 1]) {
                continue;
            }
            int target = -numbers[i];
            int left = i + 1;
            int right = numbers.size() - 1;
            
            while (left < right) {
                int sum = numbers[left] + numbers[right];
                if (sum < target) {
                    ++left;
                }
                else if (sum > target) {
                    --right;
                }
                else {
                    res.push_back({numbers[i], numbers[left], numbers[right]});
                    ++left;
                    while (numbers[left] == numbers[left - 1]) ++left;
                }
            }
        }
        
        return res;
    }
};

这题的解法就是先固定一个点，再用左右两根指针，从数列头和尾开始遍历，因为数组是排好序的，所以根据这三个位置的和与target的关系移动指针，就可以找到解了。
补充问题：
443. 两数之和 II
533. 两数和的最接近值
587. 两数之和 - 不同组成
609. 两数和-小于或等于目标值

交叉链表与带环链表

380. 两个链表的交叉这类问题需要求解两个交叉链表的交点，首先我们通过一次遍历求出两根链表的长度差，再让长链表的指针先跑这个长度差，再让两根指针同时跑，这样当两根指针跑到一起的时候，这个位置就是我们要找的交点。下面给出代码。

class Solution {
public:
    /**
     * @param headA: the first list
     * @param headB: the second list
     * @return: a ListNode
     */
    ListNode * getIntersectionNode(ListNode * headA, ListNode * headB) {
        // write your code here
        if (headA == NULL or headB == NULL) {
            return NULL;
        }
        
        int lenA = 0, lenB = 0;
        ListNode * pA = headA;
        ListNode * pB = headB;
        
        while (pA != NULL) {
            pA = pA->next;
            ++lenA;
        }
        
        while (pB != NULL) {
            pB = pB->next;
            ++lenB;
        }
        
        if (lenA > lenB) {
            int diff = lenA - lenB;
            for (int i = 0; i < diff; ++i) {
                headA = headA->next;
            }
        }
        
        if (lenB > lenA) {
            int diff = lenB - lenA;
            for (int i = 0; i < diff; ++i) {
                headB = headB->next;
            }
        }
        
        while (headA and headB) {
            if (headA == headB) {
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
        }
        
        return NULL;
    }
};

有这个问题引申出一类可以通过快慢指针解决的链表问题，如228. 链表的中点，可以设置两根指针，一根快指针每次移动两个单位，一根慢指针每次移动一个单位，这样当快指针跑到链表结尾时，慢指针指向的就是链表的中点了。
同样的102. 带环链表，103. 带环链表 II也使用了快慢指针法，103这个题让与228题一样的两根快慢指针在链表上跑，当两根指针相遇时，让其中一根重新回到链表头，当他们第二次相遇时的位置便是环的起始点，这实际上在数学上可以给出证明，这里不再赘述。

去除重复元素

521. 去除重复元素，这个问题要求去除数组中的重复元素，且在原数组上进行操作。第一步我们要对数组进行排序，然后用两根指针，第一根i指针遍历这个数组，第二根m指针指向当前最后一个不重复的位置，然后比较两根指针，当所指位置元素不同时，将nums[i]赋给nums[++m]（同时自增1），代码如下。

class Solution {
public:
    /**
     * @param nums: an array of integers
     * @return: the number of unique integers
     */
    int deduplication(vector &nums) {
        // write your code here
        int n = nums.size();
        int m = 0;
        
        if (n == 0) {
            return 0;
        }
        
        sort(nums.begin(), nums.end());
        
        for (int i = 0; i < n; ++i) {
            if (nums[i] != nums[m]) {
                nums[++m] = nums[i];
            }
        }
        
        return m + 1;
    }
};

烙饼排序

894. 烙饼排序是一个很有意思的问题，对一个数组，只能进行一种翻转操作flip，flip(arr, i): 翻转数组中下标从 0 到 i 的元素。与传统的排序算法不同，传统的排序算法试图以尽可能少的比较进行排序。我们的目标是用尽可能少的翻转来实现排序，代码如下。

class Solution {
public:
    /**
     * @param array: an integer array
     * @return: nothing
     */
    void pancakeSort(vector &array) {
        // Write your code here
        int n = array.size();
        vector::iterator it;
        for (int i = n; i >= 1; --i) {
            it = std::max_element(array.begin(), array.begin() + i);
            if (it != array.begin() + i - 1) {
                FlipTool::flip(array, it - array.begin());
                FlipTool::flip(array, i - 1);
            }
        }
    }
};