【leetcode刷题笔记】

206.反转链表

难度：简单
我写的：（妖魔化双指针，做的时候画图就好）

class Solution {
public:
    ListNode* temp;
    ListNode* reverseList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode* now = head -> next;
        ListNode* last = head;
        while(head -> next){
            head -> next = now -> next;
            now -> next = last;
            last = now;
            now = head -> next;
            
        }
        return last;        
    }
};

递归写法：
https://leetcode-cn.com/problems/reverse-linked-list/solution/dong-hua-yan-shi-206-fan-zhuan-lian-biao-by-user74/

class Solution {
public:
    ListNode* reverseList(ListNode* head) {       
        if(!head || !head->next) return head;
        ListNode* temp = reverseList(head->next);//函数栈里的临时变量
        head -> next -> next = head;
        head -> next = NULL;
        return temp;//每次函数栈中的temp不变 都是最后一个元素，忘记就回顾链接里的ppt
    }
};

要多加强函数栈学习5555555

146. LRU 缓存

2022-2-28

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) //如果关键字 key存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) // 如果关键字 key
已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过capacity ，则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

链接：https://leetcode-cn.com/problems/lru-cache

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

其中将已存在的结点挪到链表头部，相当于删除再插入结点，有利于代码复用。

class LRUCache {
public:
    int cap;
    int num;
    struct LRUNode{
        int key;
        int value;
        LRUNode* next;
        LRUNode* last;
        LRUNode(int _key,int _value): key(_key),value(_value),next(NULL),last(NULL){}
    }*L;
    map<int, LRUNode*> cache;
    LRUNode* head = new LRUNode(-1, -1);
    LRUNode* tail = new LRUNode(-1, -1);
    LRUCache(int capacity) {
        
        head -> next = tail;
        head -> last = tail;
        tail -> next = head;
        tail -> last = head;
        cap = capacity;
        num = 0;
        
    }
    void remove(LRUNode* p){
        p -> last -> next = p -> next;
        p -> next -> last = p -> last;
    }
    void insert(LRUNode* p){
        head -> next -> last = p;
        p -> next = head -> next;
        head -> next = p;
        p -> last = head;
    }
    int get(int key) {
        if(cache.count(key) == 0) return -1;
        remove(cache[key]);
        insert(cache[key]);
        
        return cache[key]->value;
    }
    
    void put(int key, int value) {
        
        if(cache.count(key) == 0){
        
            if(++num > cap){
                map<int, LRUNode*>::iterator it;
                it = cache.find(tail -> last -> key);
                cache.erase(it);
                remove(tail -> last);
            }
        }
        else{
            remove(cache[key]);
            
        }
        LRUNode* p = new LRUNode(key, value);
        
        insert(p);
        cache[key] = p;
        
    }
};

顺便学习了一下 java的hashmap
https://www.cnblogs.com/chengxiao/p/6059914.html

102.二叉树层序遍历

东北大学今年的一道初试题哈哈，博主早就做过了 想笑
唉 三个编程都做出来了但是分不高 伤心
难度：中等（简单）评分：AS

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {

        vector<vector<int>> ans;
        if(!root) return ans;
        queue<TreeNode*> q;
        q.push(root);
        int num = q.size();
        while(!q.empty()){
            vector<int> an;
            int j = 0;
            for(int i = 0; i < num; ++i){
                TreeNode* temp = q.front();
                q.pop();
                an.push_back(temp->val);
                if(temp -> left) {
                    q.push(temp->left);
                    
                    ++j;
                }
                if(temp -> right) {
                    q.push(temp->right);
                    
                    ++j;
                }
                
            }
            ans.push_back(an);
            num = j;
            
            
        }
        return ans;
    }
};

103.二叉树的锯齿层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
难度：中等 评分：SA
也就是102的变形，102使用的是队列，103这里使用双栈，顺序反过来奇数次就是逆序，顺序反偶数次仍为原顺序。

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(!root) return ans;
        vector<TreeNode*> l,r;
        l.emplace_back(root);
       // bool flag = false;
        while(!l.empty()){
            vector<int> an;
            int num = l.size();
            for(int i = 0; i < num; ++i){
                
                TreeNode* temp = l.back();
                l.pop_back();
                
                an.emplace_back(temp->val);
                if(!(ans.size() & 1)){//通过二维数组中一维数组的个数判断是奇数行还是偶数行
                    if(temp -> left){
                        r.emplace_back(temp -> left);

                    }
                    if(temp -> right){
                        r.emplace_back(temp -> right);
                    }

                }
                else {
                    if(temp -> right){
                        r.emplace_back(temp -> right);
                    }
                    if(temp -> left){
                        r.emplace_back(temp -> left);
                    }
                }   
            }
            ans.emplace_back(an);
            l.swap(r);
            r.clear();            
        }
        return ans;
        
    }
};