双指针算法

双指针

• 快慢指针一般用于链表
• 左右指针一般用于数组或者字符串，可以random access

快慢指针

判断链表中是否有环

leetcode 141 环形链表

• slow\fast 指针同时出发，让fast的速度是slow的2倍
• 如果fast 遇到了null,说明无环
• 否则slow 和fast 会进入环内，会最终相遇，说明有环

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast  = head;
        while(fast && fast->next){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow) return true;
        }
        return false;
    }
};

如果链表有环，求环的起始节点

leetcode 142 环形链表2

• 先判断是否有环，如果无环，return nullptr;
• slow 执行head节点，让slow fast 速度一样，他们相遇点就是环的起始节点

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        bool hasCycle = false;
        while(fast && fast->next){
            fast = fast->next->next;
            slow = slow->next;
            if(slow == fast){
                hasCycle = true;
                break;
            }
        }
        if(!hasCycle) return nullptr;
        slow = head;
        while(slow != fast){
            slow = slow->next;
            fast = fast->next;
        }
        return slow;
    }
};

求链表的中点

leetcode 876 链表的中间节点

• fast 的速度是 slow的2倍，当fast结束时，slow运行到中间。
• 当链表长度是奇数时，slow是中间
• 当链表长度是偶数时，slow是中间偏右的节点

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* slow = head,*fast = head;
        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

求链表倒数第K个节点

leetcode 面试 02.02 返回倒数第k个节点

• fast 先走k 个节点后，slow在开始walk，他们速度一样
• 当fast走到最后(即遇到为null)，slow就是倒数第k个节点

lass Solution {
public:
    int kthToLast(ListNode* head, int k) {
        ListNode* slow = head;
        ListNode* fast = head;
        while(k--){
            fast = fast->next;
        }
        while(fast){
            slow = slow->next;
            fast = fast->next;
        }
        return slow->val;
    }
};

链表的归并排序

leetcode 184 链表排序

• 快慢指针找到链表的中间节点，把中间节点之前的next设为null，这样右边界就可以自然出来
• 排序使用归并，merge的时候不需额外空间，最为合适
• 递归的结束：当 !node || !node->next，即当前节点为空，或者是最后一个时，直接返回

class Solution {
    
    ListNode* merget(ListNode* l,ListNode* r){
        if(!l) return r;
        if(!r) return l;
        if(l->val < r->val){
            l->next = merget(l->next,r);
            return l;
        }
        r->next = merget(l,r->next);
        return r;
    }
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode* slow = head,*fast = head,*prev = slow;
        while(fast && fast->next){
            fast = fast->next->next;
            prev = slow;
            slow = slow->next;
        }
        //prev是slow的前驱元素，设为null后
        prev->next = nullptr;
        return merget(sortList(head),sortList(slow));
    }
};

有序数组/链表去重

leetcode 26 删除排序数组中的重复项

• slow 指针指向未重复数组的最后一个
• fast指针walk，判断每一个值是否和slow不同，如果不同，slow前移，把fast节点值assign给slow

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
       if(nums.size() < 2) return nums.size();
       int slow = 0,fast = 1;
       for(;fast < nums.size();++fast){
           if(nums[fast] != nums[slow]) nums[++slow] = nums[fast];
       } 
       return ++slow;
    }
};

leetcode 83 删除排序链表中的重复元素

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) return head;
        ListNode* slow = head,*fast = head->next;
        while(fast){
            if(fast->val != slow->val){
                slow->next = fast;
                slow = slow->next;
            }
            fast = fast->next;
        }
        slow->next = nullptr;
        return head;
    }
};

左右指针

二分查找

leetcode 34 在排序数组中查找元素的第一个和最后一个位置

• 使用二分查找
• 第一个出现的元素，由右向左逼近
• 最后一个，由左向右逼近

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> res;
        int n = nums.size(); 
        if(n == 0) return vector<int>{-1,-1};      
        int l =0,r = n-1,m;
        while(l < r){
            m = (l + r)/2;
            if(nums[m] >= target) r = m;
            else l++;
        }
        if(nums[l] != target) return {-1,-1};
        res.push_back(l);
        r = n;
        while(l<r){
            m = (l + r)/2;
            if(nums[m] <= target) l = m + 1;
            else r--;
        }
        res.push_back(l-1);
        return res;
    }
};

反转数组

leetcode 344 反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) {
        int l = 0, r = s.size() -1;
        char tmp;
        while(l < r){
            if(s[l] != s[r]){
                tmp = s[r];
                s[r] = s[l];
                s[l] = tmp;
            }
            l++;
            r--;
        }
    }
};

n数之和

滑动窗口

• 窗口大小已知，进行滑动
• 窗口大小未知，但是有其他规则可以让窗口扩大和缩小