文章目录
- 贰 数据结构系列
- 2-1 手写LRU（`Least Recently Used`）缓存淘汰算法
- 2-2 手写LFU缓存淘汰算法
- 2-2 二叉搜索树合集
- 2-3 完全二叉树的节点
- 2-4 各种遍历框架序列化和反序列化 二叉树
- 2-5 Git 原理之二叉树 最近公共祖先
- 2-6 单调栈
- 2-7 特殊数据结构 --- 单调队列
- 2-7-1框架 ：
- 2-7-2
- 一、 [239. 滑动窗口最大值](https://leetcode-cn.com/problems/sliding-window-maximum/)
- 二、 [480. 滑动窗口中位数](https://leetcode-cn.com/problems/sliding-window-median/)
- 三、 [剑指 Offer 59 - I. 滑动窗口的最大值](https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/)
- 四、 [剑指 Offer II 041. 滑动窗口的平均值](https://leetcode-cn.com/problems/qIsx9U/)
- 2-7-3 [232. 用栈实现队列](https://leetcode-cn.com/problems/implement-queue-using-stacks/)
- 2-8 判断回文链表
- 2-9 【秀操作】递归反转链表
- 2-10 k个一组反转链表
贰 数据结构系列
2-1 手写LRU（Least Recently Used）缓存淘汰算法
JS中的Map是有序的！！！！
2-1-1 讲解
- LRU ： least Recently Used
- put和get方法的时间复杂度为O(1)，cache必备 【任意位置快速插入和删除元素】：
- cache有时序，区分最近使用的数据，满了之后删除最久未使用的数据
- cache中快速找某个key是否存在并得到对应的val
- 每次访问cache中的某个key，需要get该元素未最近使用
- 哈希查找快，双链表插入和删除快------> 哈希链表LinkedHaspMap
2-1-2 相关例题
一、 146. LRU 缓存
-
自己实现LRU算法
class LRUCache { private HaspMap<Integer, Node> map; private DoubleList cache; // 最大容量 private int cap; public LRUCache(int capacity) { this.cap = capacity; map = new HashMap<>(); cache = new DoubleList(); } } // ---------------------实现put和get方法------------ public int get(int key) { if(!map.containsKey(key)) { return -1; } // 将该数据提升为最近使用的 makeRecently(key); return map.get(key).val; } public ivoid put(int key, int val) { if (map.containsKey(key)) { } } // -----------------抽象一层API----------------- // 将某个key提升为最近使用 private void addRecently(int key, int val) { Node x = map.get(x); // 先从链表中删除这个节点 cache.addLast(x); // 重新插入队尾 cache.addLast(x); } // 添加最近使用的元素 private void addRecently(int key, int val) { Node x = new Node(key, val); // 链表尾部就是最近使用的元素 cache.addLast(x); // map中添加key的映射 map.put(key, x); } // 删除某一个key private void deleteKey(int key) { Node x = map.get(key); // 从链表中删除 cache.remove(x); // 从map中删除 map.remove(key); } // 删除最旧未使用的元素 private void removeLeastRecently() { // 链表头部的第一个元素最久未使用 Node deletedNode = cache.removeFirst(); // 别忘了从map中删除key int deletedKey = deleteNode.key; map.remove(deletedKey); } // -------------以下是双向链表的实现----------------- // 双链表的节点类 class Node { public int key,val; public Node next,prev; public Node(int k, int v) { this.key = k; this.val = v; } } // 依靠Node类型构建一个双链表 class DoubleList { // 头尾虚节点 private Node head, tail; // 链表元素数 private int size; public DoubleList() { /// 初始化双向链表的数据 head = new Node(0,0); tail = new Node(0,0); head.next = tail; tail.pre = head; } // 链表尾部添节点x public void addLast(Node x) { x.prev = tail.prev; x.next = tail; tail.prev.next = x; tail.prev = head; size = 0; } // 删除链表中的x节点---》 使用双向链表，完成删除操作，需要得到前驱节点的指针 // 尾部的元素最近使用 public void remove(Node x) { x.prev.next = x.next; x.next.prev = x.prev; size---; } // 删除链表第一个节点，返回该节点 public Node removeFirst() { if(head.next === tail) return null; Node first = head.next; remove(first); return first; } // 返回链表长度 public int size() { return size; } } -
同时维护一个双链表cache和哈希表map， 遇到问题 ：
-
删除某个key时，在cache中删除对应的Node，忘记在map中删除key
-
解决方法 ： 在两种数据结构上抽象出一层抽象API
-
2-2 手写LFU缓存淘汰算法
2-2-1 思路分析
-
- 调用get (key)时： 返回该key对应val
- 用get或put方法访问一次某个key，该key的freq加一
- 如果在容量满时插入，需要将freq最小的key删除
- 最小的freq对应多个key时，删除最旧的
- 希望在O(1)时间复杂度解决，使用基本数据结构
- HashMap存储key到val的映射，快速计算get(key)
- HashMap<Integer, Integer> keyToVal;
- 使用一个HashMap存储key到freq的映射，快速操作key对应freq
- HashMap<Integer, Interger> keyToFreq;
- 核心需求 ：
- 需要Freq到key的映射
- 将freq最小的key删除，快速得到当前所有key最小的freq是多少。O(1)-----> minFreq
- 多个key拥有相同的freq，freq对key是一对多的关系
- freq对应的key的列表存在时序
- 快速删除 key列表片中的任何一个key，频次为freq的某个key被访问，频次就会变成freq+1。
- HashMap存储key到val的映射，快速计算get(key)
- Java ：
- LinkedHashSet 是链表和哈希结合的集合体。
- 链表查找慢，插入元素具有时序
- 哈希表元素无序，可以对于元素进行快速访问和删除
- JS ： map有序，哈哈~！！！！
- 两个map && 链表 && 三个Map - LFU 缓存 - 力扣（LeetCode） (leetcode-cn.com))
- 这题解详细
2-2 二叉搜索树合集
二叉树的设计总路线：明确一个节点要做的事情，剩下的抛给框架
2-2-1 判断二叉搜索树的合法性
五、 98. 验证二叉搜索树
纳闷了就，做以前以为自己学会了，结果 n次bug通不过，回去看题解，给我整不会了？？？？
-
思路如下 ：
- 树为空，返回true
- 根节点 < 左子节点 || 根节点 > 右子节点,返回false
- 出现如下问题：
- 出现如下问题：
- 需要约束root的左子树 小于 root 以及…
-
var isValidBST = function(root) { return isValidBST2(root,null,null); }; let isValidBST2 = (root,min,max) => { if(root === null) return true; if(min != null && root.val <= min.val) return false; if(max != null && root.val >= max.val) return false; // 确保右子树小于 最大值root，确保左子树大于最小值root return isValidBST2(root.left, min, root) && isValidBST2(root.right, root, max); }
2-2-2 在BST中查找一个数是否存在
-
二分搜索思想：
const isBST(TreeNode root, int target) { // root 该做的事 if (root === null) return false; if (root.val === target) return true; if(root.val < target) return isInBST(root.right, target); if(root.val > target) return isInBST(root.left, target); } -
一套针对BST的遍历框架
const BST(TreeNode root,int target) { if(root.val === target) // 找到目标，做事情 if(root.val < target) BST(root.right, target); if (root.val > target) BST(root.left, target); }
2-2-3 在BST中插入一个数
TreeNode insertIntoBST(TreeNode root, int val) {
// 找到空位置 插入新节点
if (root === null) return new TreeNode(val);
// 如果已经存在，不要再重复插入，直接返回
if (root.val === val){
return root;
}
if(root.val < val){
root.right = insertIntoBST(root.right, val);
if(root.val >val)
root.left = insertIntoBST(root.left, val);
return root;
}
}
2-2-4 在BST中删除一个数
- 框架 ：
TreeNode deleteNode(TreeNode root, int key) {
if (root.val === key) {
// 找到删除
} else if (root.val > key){
root.left = deleteNode(root.left, key);
} else if (root.val < key){
// 去右子树寻找key
root.right = deleteNode(root.right, key);
}
return root;
}
-
删除方法实现
- A恰好是末端节点
- A只有一个非空子结点
- A有两个子结点
2-3 完全二叉树的节点
222. 完全二叉树的节点个数
-
普通二叉树的遍历：
const countNodes(root){ if (root === null) return 0; return 1 + countNodes(root.left) + countNodes(root.right); } -
满二叉树的遍历： 节点数和树的高度呈指数关系： 2h-1
const countNodes(TreeNode root){ let h =0; while(root !== null) { root = root.left; h++; } // 节点总数为 return Math.pow(2,h) - 1; }
2-4 各种遍历框架序列化和反序列化 二叉树
序列化和反序列化 ：
- 以某种固定格式组织字符串，使得数据独立于编程语言
- --------------> 序列化--------->接收JSON字符串-----> 反序列化----------------> 原始数据
2-4-1 前序二叉树
- 反序列化 ： 序列化列表的第一个元素就是一棵树的根节点，只要将列表的第一个元素取出作为根节点，剩下的交给递归函数
2-4-2 后序二叉树
- 反序列化时，找列表的最后一个元素
2-4-3 层序二叉树
2-5 Git 原理之二叉树 最近公共祖先
Git的rebase 引出一个经典的算法问题：最近公共祖先(Lowest Common Ancestor，简称LCA)
- git pull
- git pull -r
- 遇到任何递归型的问题，灵魂三问 ：
- 这个函数是干什么的
- 这个函数参数中的变量是什么
- 得到参数的递归结果，应该做什么
lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)- p,q都在以root为根的树中，函数返回的即是p和q的最近公共祖先节点
- 如果p/q都不在以root为根的树中 ： 函数返回null
- 如果p和q只有一个存在于以root为根的树中
2-6 单调栈
先进后出
- 单调栈：使得每次新元素入栈后，栈内的元素保持单调
- 只解决Next Greater Element
496. 下一个更大元素 I ： 两个数组
2-6-1 单调栈的解题模板
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TZH7Uh9l-1650208185247)(https://gitee.com/hannah_bingo/yyy/raw/master/image-20220405092146085.png)]
-
var nextGreaterElement = function (nums1, nums2) { let stack = []; let map = new Map(); for (let i = 0; i < nums2.length; i++) { while (stack.length && nums2[i] > nums2[stack[stack.length - 1]]) { let index = stack.pop(); map.set(nums2[index], nums2[i]); } stack.push(i); } let res = []; for (let j = 0; j < nums1.length; j++) { res[j] = map.get(nums1[j]) || -1; } return res; };
2-6-2 循环数组
-
/** * @param {number[]} nums * @return {number[]} */ var nextGreaterElements = function(nums) { const m = nums.length; const res = new Array(m).fill(0); const stack = []; // 将数组长度翻倍 for (let i = 2*m-1; i >= 0; i--){ // 反向入栈 while (stack.length && nums[i%m] >= stack[stack.length -1]) { // 大于栈顶元素 stack.pop(); } // 利用 % 求模 防止索引越界 res[i%m] = stack.length ? stack[stack.length -1] : -1; stack.push(nums[i%m]); } return res; };
2-6-3 556. 下一个更大元素 III
/**
* @param {number} n
* @return {number}
*/
// function nextGreaterElement(n) {
// let res = 0
// let q = []
// let str = Array.from(String(n))//字符串数组
// for (let i = str.length - 1; i >= 0; i--) {
// if (q.length === 0 || str[i] >= q[q.length - 1]) q.push(str[i]) ;
// else {
// let count = 0
// // 出栈，记录出栈的位数
// while (q.length !== 0 && str[i] < q[q.length - 1]) {
// q.pop()
// count++
// }
// [str[i], str[i + count]] = [str[i + count], str[i]] // swap元素
// res = parseInt(
// str.slice(0, i + 1).join('') +
// str.slice(i + 1).reverse().join('')
// ) // 反转右边
// return res >= 2 ** 31 - 1 ? -1 : res
// }
// }
// return -1
// }
/**
* @param {number} n
* @return {number}
*/
// var nextGreaterElement = function(n) {
// let s = ('' + n).split('');
// let i = s.length - 2;
// while (s[i] >= s[i + 1]) i--; // 从右开始，找第一个严格降序的数字
// if (i < 0) return -1; // 不存在，返回-1
// let j = s.length - 1;
// while (s[j] <= s[i]) j--; // 从右开始，找到第一个比上一步找到数字大的
// [ s[i], s[j] ] = [ s[j], s[i] ]; // 换位
// let res = parseInt(s.slice(0, i + 1).join('') + s.slice(i + 1).reverse().join('')); // 反转右边
// return res >= 2 ** 31 - 1 ? -1 : res;
// };
/**
* @param {number} n
* @return {number}
*/
var nextGreaterElement = function(n) {
// 把 n 字符串化
const nStr = n + ''
const len = nStr.length
// 我们从后往前遍历，找到第一个比他后面的最大数字小的一个数字，这个位置的数字就是我们要更换的数字
let max = nStr[len - 1]
// 已经遍历过的数字组成的数字，当我们已经更换的数字更换了之后，这个数组就保存更换数字之后的所有数字，我们取得这个数组能组成的数字的最小值拼接在后面即可
const after = [max]
// 需要更换的数字的位置
let before = -1
for (let i = len - 2; i >= 0; i--) {
if (nStr[i] < max) {
before = i
break;
} else {
max = nStr[i]
after.unshift(nStr[i])
}
}
// 当没有需要更换的数字，表示重排找不到比 n 最大的数字了，返回 -1
if (before < 0) return -1
// 保存需要更换的数字
let num = nStr[before]
// after数组从小到大排序，到时候直接拼接就是能组合的最小数字
after.sort((a, b) => a - b)
// 遍历after数组，找到第一个比 num 大的数，来和 num 做交换
for (let i = 0, len = after.length; i < len; i++) {
if (after[i] > num) {
const temp = after[i]
after[i] = num
num = temp
break
}
}
// 拼接数字
// 需要更换的数字之前 + 更换的后数字 + 更换的数字位置之后的所有数字能组成的最小数字
const ret = +(nStr.slice(0, before) + num + after.join(''))
return ret <= (2 ** 31 - 1) ? ret : -1
};
2-7 特殊数据结构 — 单调队列
2-7-1框架 ：
int[] maxSlidingWindow(int[] nums, int k) {
MonotonicQueue window = new MonotonicQueue();
List<Integer> res = new ArrayList<>();
for(int i = 0; i<nums.length; i++){
if(i <k-1){
// 先把 窗口的前 k-1 填满
window.push(nums[i]);
} else {
// 窗口开始向前滑动
// 移入新元素
window.push(nums[i]);
// 将当前窗口中的最大元素计入结果
res.add(window.max());
// 移出最后的元素
window.pop(nums[i- k + 1]);
}
}
// 将List 类型转换为int[]数组作为返回值
int[] arr = new int[res.size()];
for (int i = 0; i< res.size(); i++){
arr[i] = res.get(i);
}
return arr;
}
2-7-2
一、 239. 滑动窗口最大值
队列中只有一个，队头持续是最大的
-
若队列不为空，且当前元素大于等于队尾所存下标的元素，则弹出队尾
-
入队当前元素下标
-
判断当前最大值（即队首元素）是否在窗口中，如不在便将其出队
-
当达到窗口大小时 开始 向结果中添加数据
var maxSlidingWindow = function (nums, k) { // 队列数组（存放的是元素下标，为了取值方便） const q = []; // 结果数组 const ans = []; for (let i = 0; i < nums.length; i++) { // 若队列不为空，且当前元素大于等于队尾所存下标的元素，则弹出队尾 while (q.length && nums[i] >= nums[q[q.length - 1]]) { q.pop(); } // 入队当前元素下标 q.push(i); // 判断当前最大值（即队首元素）是否在窗口中，若不在便将其出队 while (q[0] <= i - k) { q.shift(); } // 当达到窗口大小时便开始向结果中添加数据 if (i >= k - 1) ans.push(nums[q[0]]); } return ans; }; 。
二、 480. 滑动窗口中位数
三、 剑指 Offer 59 - I. 滑动窗口的最大值
四、 剑指 Offer II 041. 滑动窗口的平均值
2-7-3 232. 用栈实现队列
-
看看这里的动画，会好很多 ： 232. 用栈实现队列:【两个栈来模拟队列】详解 - 用栈实现队列 - 力扣（LeetCode） (leetcode-cn.com)
-
var MyQueue = function() { this.inStack = []; this.outStack = []; }; MyQueue.prototype.push = function(x) { this.inStack.push(x); }; MyQueue.prototype.pop = function() { if (!this.outStack.length) { this.in2out(); } return this.outStack.pop(); }; MyQueue.prototype.peek = function() { if (!this.outStack.length) { this.in2out(); } return this.outStack[this.outStack.length - 1]; }; MyQueue.prototype.empty = function() { return this.outStack.length === 0 && this.inStack.length === 0; }; MyQueue.prototype.in2out = function() { while (this.inStack.length) { this.outStack.push(this.inStack.pop()); } };
2-8 判断回文链表
2-8-1
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
/**
* @param {ListNode} head
* @return {boolean}
*/
var isPalindrome = function(head) {
let left = 0;
const res = [];
let sign = true;
while(head !== null){
res.push(head.val);
head = head.next;
}
// console.log(res)
let right = res.length-1;
while(left < right) {
if(res[left]!== res[right]) {
sign = false
}
left++;
right--;
}
return sign
};
/**
* @param {string} s
* @return {boolean}
*/
var isPalindrome = function(s) {
let str = s.toLowerCase()
let len = str.length
let arr = []
for(let i = 0;i < len;i++){
if(str.charCodeAt(i) >= 97 && str.charCodeAt(i) <= 122) arr.push(str[i])
if(str.charCodeAt(i) >= 48 && str.charCodeAt(i) <= 57) arr.push(str[i])
}
if(arr === []) return true
str = arr.join('')
str2 = arr.reverse().join('')
if(str === str2) return true
return false
};
2-8-2 双指针技巧【我不当独秀，不学了不学了】
2-9 【秀操作】递归反转链表
2-9-1
2-10 k个一组反转链表
- base case : 如果最后的元素不足k个，就保持不变
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
