【代码随想录第3天】链表1

76.最小覆盖子串（难）

题目链接：76.最小覆盖子串

滑动窗口

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map <char, int> tmap;
        // t的字符个数存入哈希表
        for(char ch : t){
            ++tmap[ch];
        }
        int min_len = INT32_MAX;
        int correct = 0; // 记录当前窗口内包含字符串t中的字符的个数
        int i = 0;
        int start = 0; //子串起始位置
        for (int j = 0; j < s.size(); j++){
            //判断s[j]是否为t的字符，tmap中s[j]计数-1<0的不是有效字符
            //计数大于0，则s[j]是一个有效字符，包含t字符的个数+1
            if(--tmap[s[j]] >= 0) correct++; 
            //维护窗口中有效字符数=t的长度
            if(correct == t.length()){
          		//i右移直到s[i]是第一个有效字符（目前计数+1>0）
                while(++tmap[s[i]] <= 0) i++; 
                correct--;
                if(j - i + 1 < min_len){
                    min_len = j - i + 1;
                    start = i;
                }
                i++;
            }
        }
        return min_len > s.size() ? "" : s.substr(start, min_len);
    }
};

注：尝试访问不存在的键会在 unordered_map 中插入一个具有默认值(0)的键值对。
因此–tmap[s[j]]<0，要么s[j]是t中不包括的字符，要么是t中包括但多余的字符，反之则是有效字符。

链表

203.移除元素（简单）

LeetCode题目：203.移除元素
代码随想录：203.移除元素

题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
       ListNode * h = new ListNode;
       h->next = head;
       ListNode * p = h;
       while(p->next){
           if(val == p->next->val){
               ListNode * tmp = p->next;
               p->next = p->next->next;
               delete tmp;
           }else{
               p = p->next;
           }
       }
       head = h->next;
       delete h;
       return head;

    }
};

206.反转链表（简单）

LeetCode题目：206.反转链表
代码随想录：206.反转链表

双指针法：

ListNode* reverseList(ListNode* head) {
        ListNode * cur = head;
        ListNode * pre = nullptr;
        while(cur){
            ListNode * tmp = cur -> next;
            cur ->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }

递归：

    ListNode * reverse(ListNode * pre, ListNode * cur){
        if(cur == nullptr) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(cur, tmp);
    }

     ListNode* reverseList(ListNode* head) {
        return reverse(nullptr, head);
    }

707.设计链表

LeetCode题目：707.设计链表
代码随想录：707.设计链表

class MyLinkedList {
public:
    struct LinkedList{
        int val;
        LinkedList *next;
        LinkedList(int x): val(x), next(nullptr){}
    };
    MyLinkedList() {
        _dummyHead = new LinkedList(0); //虚拟头结点
        _size = 0;
    }
    
    //index从0开始，0是头结点
    int get(int index) {
        if(index > _size-1 || index < 0)
            return -1;
        LinkedList *p = _dummyHead->next;
        while(index--){
            p = p->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        LinkedList *p = new LinkedList(val);
        p->next = _dummyHead->next;
        _dummyHead->next = p;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedList *tail = new LinkedList(val);
        LinkedList *p = _dummyHead;
        while(p->next)
            p = p->next;
        p->next = tail;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if(index>_size){
            return;
        }
        LinkedList *p = _dummyHead;
        LinkedList *addNode = new LinkedList(val);
        while(index--){
            p = p->next;
        }
        addNode->next = p->next;
        p->next = addNode;
        _size++;
        
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>=_size)
            return;
        LinkedList *p = _dummyHead;
        while(index--){
            p = p -> next;
        }
        LinkedList *tmp = p->next;
        p->next = tmp->next;
        delete tmp;
        _size--;
    }

private:
    LinkedList *_dummyHead;
    int _size;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */