2022.3.17
146. LRU 缓存
/**
* @param {number} capacity
*/
var LRUCache = function(capacity) {
this.capacity = capacity;
this.map = new Map();
};
/**
* @param {number} key
* @return {number}
*/
LRUCache.prototype.get = function(key) {
// 当值存在时
if(this.map.has(key)){
const temp = this.map.get(key);
this.map.delete(key);
this.map.set(key, temp);
return temp;
}
else {
return -1;
}
};
/**
* @param {number} key
* @param {number} value
* @return {void}
*/
LRUCache.prototype.put = function(key, value) {
// 当值存在，被访问时
if(this.map.has(key)){
this.map.delete(key);
}
this.map.set(key,value);
if(this.map.size > this.capacity) {
this.map.delete(this.map.keys().next().value);
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* var obj = new LRUCache(capacity)
* var param_1 = obj.get(key)
* obj.put(key,value)
*/
class LRUCache {
constructor(capacity) {
this.capacity = capacity;
this.map = new Map();
}
get(key) {
if (this.map.has(key)) {
// get表示访问该值
// 所以在访问的同时，要将其调整位置，放置在最后
const temp = this.map.get(key);
// 先删除，再添加
this.map.delete(key);
this.map.set(key, temp);
// 返回访问的值
return temp;
} else {
// 不存在，返回-1
return -1;
}
}
put(key, value) {
// 要将其放在最后，所以若存在key，先删除
if (this.map.has(key)) this.map.delete(key);
// 设置key、value
this.map.set(key, value);
if (this.map.size > this.capacity) {
// 若超出范围，将map中头部的删除
// map.keys()返回一个迭代器
// 迭代器调用next()方法，返回包含迭代器返回的下一个值，在value中
this.map.delete(this.map.keys().next().value);
}
}
}
/**
* Your LRUCache object will be instantiated and called as such:
* var obj = new LRUCache(capacity)
* var param_1 = obj.get(key)
* obj.put(key,value)
*/
/**
* @param {number} capacity
*/
var LRUCache = function(capacity) {
this.capacity = capacity;
this.map = new Map();
};
/**
* @param {number} key
* @return {number}
*/
LRUCache.prototype.get = function(key) {
if(this.map.has(key)){
let temp=this.map.get(key)
this.map.delete(key);
this.map.set(key, temp);
return temp
}else{
return -1
}
};
/**
* @param {number} key
* @param {number} value
* @return {void}
*/
LRUCache.prototype.put = function(key, value) {
if(this.map.has(key)){
this.map.delete(key);
}
this.map.set(key,value);
if(this.map.size > this.capacity){
this.map.delete(this.map.keys().next().value);
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* var obj = new LRUCache(capacity)
* var param_1 = obj.get(key)
* obj.put(key,value)
*/
2022.3.21
460. LFU 缓存
二、 653. 两数之和 IV - 输入 BST
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @param {number} k
* @return {boolean}
*/
var findTarget = function(root, k) {
const set = new Set();
// const target = k - root.val
const searchTree = (root, k) => {
if(!root) {
return false;
}
if(set.has(k-root.val)) {
return true;
}
set.add(root.val)
return searchTree(root.left,k) || searchTree(root.right,k)
}
return searchTree(root, k)
};
2022.3.22
一、 78. 子集
/**
* @param {number[]} nums
* @return {number[][]}
*/
var subsets = function(nums) {
let result = [];
let num = [];
const backtracking = (start) => {
result.push(num.slice());
for (let i = start; i< nums.length; i++){
num.push(nums[i])
backtracking(i+1);
num.pop()
}
}
backtracking(0);
return result;
};
二、 77. 组合
/**
* @param {number} n
* @param {number} k
* @return {number[][]}
*/
var combine = function(n, k) {
let result = [];
let track = [];
const backtrack = (start) => {
if(track.length === k){
result.push(track.slice())
}
for(let i = start; i < n ;i++){
// 做选择
track.push(i+1);
backtrack(i+1)
// 撤销选择
track.pop()
}
}
backtrack(0);
return result
};
37. 解数独
36. 有效的数独
2022.3.24
一、 剑指 Offer II 056. 二叉搜索树中两个节点之和
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @param {number} k
* @return {boolean}
*/
var findTarget = function(root, k) {
const set = new Set();
const helper = (root , k) => {
if(root === null){
return false;
}
if (set.has(k-root.val)) {
return true;
}
set.add(root.val);
return helper(root.left,k) || helper(root.right, k)
}
return helper(root,k);
};
二、 剑指 Offer II 052. 展平二叉搜索树
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {TreeNode}
*/
var increasingBST = function(root) {
const res = [];
const inorder = (root, res) => {
if(root === null) return ;
inorder(root.left, res);
res.push(root.val);
inorder(root.right, res);
}
inorder(root,res);
const dummyNode = new TreeNode(-1);
let curNode = dummyNode;
for (const value of res) {
curNode.right = new TreeNode(value);
curNode = curNode.right;
}
return dummyNode.right;
};
三、 897. 递增顺序搜索树
2022.3.27
剑指 Offer 55 - I. 二叉树的深度
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var maxDepth = function (root) {
// 定义：输入一个节点，返回以该节点为根的二叉树的最大深度
if (root == null) return 0;
return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
};
