算法学习 | 双指针法回顾 LeetCode 移除元素、反转字符串、替换空格、反转字符串里的单词、反转链表、链表相交、环形链表、N数之和

一、移除元素

题目链接

思路

快慢指针，用快指针寻找新数组的元素，用慢指针更新新数组下标的位置

代码实现

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

二、反转字符串

题目链接

思路

定义两个指针，一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素

代码实现

class Solution {
public:
    void reverseString(vector<char>& s) {
        for (int i = 0, j = s.size() - 1; i < s.size()/2; i++,j--) {
            swap(s[i],s[j]);
        }
    }
};

三、替换空格

题目链接

思路

数组进行扩容，从后向前替换空格，避免从前向后替换要大量移动元素。
i指向新长度的末尾，j指向旧长度的末尾，先统计空格数量，要将2个空格替换为%20，需要增加空格数量*2个空间.如果j指向的不是空格，将j处的字符复制到i所指的位置，i和j同时向前移动；如果j指向空格，从i所指的位置依次向前填充，并将i移动到填充之后的位置，然后i和j同时向前移动

代码实现

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0;
        int sOldSize = s.size();
        for(int i = 0; i < s.size(); i++) {
            if(s[i] == ' ') {
                count++;
            }
        }
        s.resize(s.size() + count*2);
        int sNewSize =s.size();
        for( int i = sNewSize - 1, j = sOldSize - 1; j < i ; i--,j--) {
            if(s[j] != ' ') {
                s[i] = s[j];
            } else {
                s[i] = '0';
                s[i - 1] = '2';
                s[i - 2] = '%';
                i -= 2;
            }
        }
        return s;  
    }
};

四、反转字符串里的单词

题目链接

思路

1.移除多余空格：与移除元素思想一样，通过使用快指针寻找目标字符串（没有空格的字符串），使用慢指针更新目标字符串的位置，如果快指针指向的不是空格，并且慢指针指向的不是起始位置，需要在单词前手动添加空格，慢指针后移，将快指针指向的字符复制到慢指针所指向的位置，快慢指针一起向后移动。
2.将整个字符反转，将每个单词反转

代码实现

class Solution {
public:
    void reverse(string& s, int start, int end) {  // 翻转区间：左闭右闭
        for(int i = start, j = end; i < j; i++,j--) {
            swap(s[i],s[j]);
        }
    }
    void removeExtraSpaces(string& s) {
        int slow = 0;
        for(int fast = 0; fast < s.size(); ++fast) {
            if(s[fast] != ' ') {
                if(slow != 0) s[slow++] = ' ' ; //给单词之间添加空格
                while(fast < s.size() && s[fast] != ' ') { // 遇到空格说明单词结束
                    s[slow++] = s[fast++];
                }
            }
        }
        s.resize(slow); // slow的大小即为去除多余空格后的大小
    }
    string reverseWords(string s) {
        removeExtraSpaces(s); // 去除多余空格，保证单词之间只有一个空格
        reverse(s,0,s.size() - 1);
        int start = 0; // removeExtreaSpace后保证第一个单词的开始下标一定是0
        for(int fast = 0; fast <= s.size(); ++fast) {
            if(fast == s.size() || s[fast] == ' ') {
                reverse(s, start, fast - 1);
                start = fast + 1;

            }
        }
        return s;
    }
};

五、反转链表

题目链接

思路

通过改变链表的next指针的指向，直接将链表反转。
定义一个cur指针，指向头结点，再定义一个pre指针，初始化为NULL，使用临时指针保存下一个cur的位置，并改变方向（cur->next=pre），先更新pre(pre=cur)，再更新cur(cur=temp)，当cur指针指向了NULL，循环结束，链表反转完毕，pre指针指向了新的头结点，返回头结点即可。

代码实现

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp;
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre; 
    }
};

六、删除链表的倒数第N个结点

题目链接

思路

定义fast指针和slow指针，初始值为虚拟头结点，fast向前移动n步之后，fast和slow同时移动，当fast指向NULL时，slow就指向了倒数第n个结点，但是为了方便做删除，要找到被删除结点的上一个结点，因此，fast需要走n+1 步。

代码实现

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead ->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next;
        while(fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyHead->next;
    }
};

七、链表相交

题目链接

思路

链表相交，交点是指针相同

求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到和curB末尾对齐的位置，比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果curA==curB，则找到交点

代码实现

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0,lenB = 0;
        while(curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while(curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表长度，lenA为其长度
        if(lenB > lenA) {
            swap(lenA, lenB);
            swap(curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点（末位位置对齐）
        while(gap--) {
            curA = curA->next;
        }
        // 遍历curA和curB，遇到相同则直接返回
        while(curA != NULL) {
            if(curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;   
    }
};

八、环形链表

题目链接

思路

定义fast和slow指针，从头结点出发，fast指针每次移动两个结点，slow指针每次移动一个结点，如果途中相遇，说明该链表有环。从头结点发出一个指针，从相遇结点发出一个指针，这两个指针每次只走一个结点，那么当这两个指针相遇的时候就是环形入口的结点。

代码实现

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {//fast走在前面并且走两步
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，从head和相遇点同时查找直至相遇
            if(slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

九、三数之和

题目链接

思路

将数组进行排序，然后有一层for循环，i从下标0的位置开始，定义下标left在i+1的位置上，定义right在数组结尾的位置上，如果三数相加大于零，right–，相加小于零，left++，等于零的话存入result数组

代码实现

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); i++) {
            if(nums[i] > 0) { // 排序之后，第一个大于0，必然没有满足条件的三元组
                return result;
            }
            if(i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left) {
                if(nums[i] + nums[left] + nums[right] > 0) right--;
                else if(nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left],nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后，对b和c去重
                    while(right > left && nums[right] == nums[right - 1]) right --;
                    while(right > left && nums[left] == nums[left + 1]) left ++;
                    right--;
                    left++;
                }
            }
            
       }
       return result;
    }
};

十、四数之和

题目链接

思路

两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况

代码实现

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for(int k = 0; k < nums.size(); k++) {
            //剪枝处理
            if(nums[k] > target && nums[k] >= 0) {
                break;
            }
            // 对nums[k]进行去重
            if(k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size() ;i++) {
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                //对nums[i]去重
                if(i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while(right > left) {
                    if((long) nums[k] + nums[i] + nums[left] +nums[right] > target) {
                        right--;
                    } 
                    else if((long) nums[k] + nums[i] + nums[left] +nums[right]  <target)
                           { left++; }
                    else{
                        result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        // 对nums[left]和nums[right]去重
                        while(right > left && nums[right] == nums[right - 1]) right--;
                        while(right > left && nums[left] == nums[left + 1]) left++;
                        //找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
 
        }
        return result;
    }
};