两周刷题记录

最新推荐文章于 2024-08-25 02:40:51 发布

牛小小小婷～

最新推荐文章于 2024-08-25 02:40:51 发布

阅读量1.6k

点赞数 1

分类专栏：数据结构文章标签： leetcode 数据结构链表

本文链接：https://blog.csdn.net/hannah2233/article/details/123784513

版权

数据结构专栏收录该内容

16 篇文章 0 订阅

订阅专栏

两周整了这么点，我真废物。还有，操蛋微信开发者工具，淦，我都在忙什么？？？
md，还有操作系统和硬件，真TM难，又是骂骂咧咧的一晚上，这文章怕怕不能发出去，🤣，睡！

2022.3.17

146. LRU 缓存

请你设计并实现一个满足 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) 的平均时间复杂度运行。

/**
 * @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 缓存

请你为最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
int get(int key) - 如果键 key 存在于缓存中，则获取键的值，否则返回 -1 。
void put(int key, int value) - 如果键 key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除最近最久未使用的键。

二、 653. 两数之和 IV - 输入 BST

给定一个二叉搜索树 root 和一个目标结果 k，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。

/**
 * 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. 组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

/**
 * @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));
};

牛小小小婷～

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
两周刷题记录

两周整了这么点，我真废物。还有，操蛋微信开发者工具，淦，我都在忙什么？？？md，还有操作系统和硬件，真TM难，又是骂骂咧咧的一晚上，这文章怕怕不能发出去，🤣，睡！2022.3.17146. LRU 缓存请你设计并实现一个满足 LRU (最近最少使用) 缓存约束的数据结构。实现 LRUCache 类：LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的.
复制链接

扫一扫