leetcode刷题记录 1.2 数组

参考:labuladong的算法小抄，自己按照思路手写了一遍 https://labuladong.github.io/algo/di-ling-zh-bfe1b/shuang-zhi-fa4bd/

写在前面

两种常用的双指针：

• 左右指针：相向而行
• 快慢指针：同向而行（单链表大部分是这种）

LeetCode题集

26. Remove Duplicates in Sorted Array

https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/

快慢指针。先判断数组是否为空。
注意赋值方式是nums[slow] = nums[fast]
满足条件时先对slow ++

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

26. Remove Duplicates in Sorted List 删除有序链表中的重复元素

和上面一样，注意最后要把slow->next断开

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

27: Remove elements

https://leetcode.com/problems/remove-element/description/

1. slow和fast都从0开始
2. 如果nums[fast] == val，则跳过；反之，则赋值给slow，然后slow++

思路有点别扭，核心就是要遍历一遍，slow要从1填到k.
最后返回slow即可

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

283: Move zeros

参考上面，先去除所有的0，再把后面对元素全部赋值为0

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        if(nums.size() ==0 ) {
            return;
        }
        int p1=0, p2=0;       
        while(p2 < nums.size()){
            if(nums[p2]!=0){
                nums[p1] = nums[p2];
                p1++;
            }
            p2++;
        }
        for(int i=p1; i<nums.size(); i++){
            nums[i] = 0;
        }
    }
};

滑动窗口有点复杂，先不看

二分查找 & 169 两数之和

有点长，挑个完整点的时间看

344 反转字符串

没啥好说的，很简单

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

5 最长回文子串

https://leetcode.com/problems/longest-palindromic-substring/description/

1、 从中心向两端扩散的双指针技巧。难点是最长回文子串可能是奇数也可能是偶数。
2、先写一个palindrome函数，入参是s, l和r
3. 遍历s，对于每个索引i，寻找以i为中心的最长回文子串，以及以i和i+1为中心的最长回文子串。
注意：string s.substr(x, y)的传参，x是起始位置，y是字符串长度。这里x = i+1，y=j-i+1

class Solution {
public:
    string longestPalindrome(string s) {
        string result = "";
        for(int i=0; i<s.size(); i++){
            string s1 = palindrome(s, i, i+1);
            string s2 = palindrome(s, i, i);
            result = result.size()>s1.size()? result:s1;
            result = result.size()>s2.size()? result:s2;
        }
        return result;
    }
    string palindrome(string s, int l, int r){       
        while(l>=0 && r < s.size() && s[l]==s[r]){
            l--;
            r++;
        }
        return s.substr(l+1, r-l-1);
    }
};

6. 合并有序数组

这个是归并排序来的衍生题目，leetcode 88 https://leetcode.cn/problems/merge-sorted-array/solutions/666608/he-bing-liang-ge-you-xu-shu-zu-by-leetco-rrb0/
使用逆向双指针，原地修改数组，空间复杂度为1.

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        p1, p2 = m-1, n-1
        tail = m+n-1
        while p1 >= 0 or p2 >= 0:
            if p1 == -1:
                nums1[tail] = nums2[p2]
                p2 -= 1
            elif p2 == -1:
                nums1[tail] = nums1[p1]
                p1 -= 1
            elif nums1[p1] > nums2[p2]:
                nums1[tail] = nums1[p1]
                p1 -= 1
            else:
                nums1[tail] = nums2[p2]
                p2 -= 1
            tail -= 1
        return