LeetCode - 460 LFU缓存（Java JS Python）

news2025/1/11 18:46:06

题目来源

460. LFU 缓存 - 力扣（LeetCode）

题目描述

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

实现 LFUCache 类：

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

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例

输入

["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [3], [4, 4], [1], [3], [4]]

输出

[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释

// cnt(x) = 键 x 的使用计数
// cache=[] 将显示最后一次使用的顺序（最左边的元素是最近的）
LFUCache lfu = new LFUCache(2);
lfu.put(1, 1);   // cache=[1,_], cnt(1)=1
lfu.put(2, 2);   // cache=[2,1], cnt(2)=1, cnt(1)=1
lfu.get(1);      // 返回 1
                 // cache=[1,2], cnt(2)=1, cnt(1)=2
lfu.put(3, 3);   // 去除键 2 ，因为 cnt(2)=1 ，使用计数最小
                 // cache=[3,1], cnt(3)=1, cnt(1)=2
lfu.get(2);      // 返回 -1（未找到）
lfu.get(3);      // 返回 3
                 // cache=[3,1], cnt(3)=2, cnt(1)=2
lfu.put(4, 4);   // 去除键 1 ，1 和 3 的 cnt 相同，但 1 最久未使用
                 // cache=[4,3], cnt(4)=1, cnt(3)=2
lfu.get(1);      // 返回 -1（未找到）
lfu.get(3);      // 返回 3
                 // cache=[3,4], cnt(4)=1, cnt(3)=3
lfu.get(4);      // 返回 4
                 // cache=[3,4], cnt(4)=2, cnt(3)=3

提示

  • 1 <= capacity <= 104
  • 0 <= key <= 105
  • 0 <= value <= 109
  • 最多调用 2 * 10^5 次 get 和 put 方法

题目解析

LFU缓存可以通过：两个哈希表(Map结构) + 双向链表来实现。

我们可以定义两个哈希表keyMap和freqMap，其中：

  • keyMap的键是"本题key"，值为"双向链表节点node"
  • freqMap的键是"本题key的使用次数freq"，值为”对应使用次数freq的key对应的node组成的双向链表“

而双向链表节点node用于记录key的如下信息：

  • key：本题的key
  • val：本题的value
  • freq：对应key使用次数

可能上面说法比较晦涩，下面通过图示来说：

‘

以上就是两个哈希Map，以及双向链表完成LFU缓存的逻辑。

上面逻辑中，有一个问题，那么就是每次LFU容量不足时，我们需要删除掉最少、最远使用的key，那么首先如何找到最少使用次数的key呢？

上面图示中，我们是通过人眼识别出freqMap键列中最小的键，即为最少使用次数。

那么代码该如何实现呢？

我们可以定义一个全局变量（或者类静态变量）minFreq来记录最少使用次数，而minFreq的更新有如下时机：

  • 1、put新增操作一定会带来一个使用次数freq=1的键，且此新键的使用次数1一定是最少的，此时我们可以更新minFreq=1
  • 2、get和put更新操作会新增对应key的使用次数，因此在新增使用次数后，该key需要从对应使用次数的DLink中去除，如果对应DLink只有该key对应节点，且对应DLink是最少使用次数对应的容器链表，那么删除key后，该DLInk就为空，那么最少使用次数的key就没了。此时我们可以直接将minFreq++，因为如果当前key在新增使用次数前是唯一的最少使用次数key，那么当前key新增使用次数后，依旧是最少使用次数的key。而minFreq就是当前key新增使用次数前的使用次数。

Java算法源码

import java.util.HashMap;

class LFUCache {
  /** 双向链表节点 */
  static class Node {
    /** 记录本题的键 */
    int key;

    /** 记录本题的值 */
    int val;

    /** 记录该键被访问的次数 */
    int freq;

    /** 当前节点的上一个节点 */
    Node prev;

    /** 当前节点的下一个节点 */
    Node next;

    public Node(int key, int val, int freq) {
      this.key = key;
      this.val = val;
      this.freq = freq;
      this.prev = null;
      this.next = null;
    }
  }

  /** 双向链表 */
  static class Link {
    /** 链表中节点个数 */
    int size;

    /** 链表头节点 */
    Node head;

    /** 链表尾节点 */
    Node tail;

    public Link() {
      this.size = 0;
      this.head = null;
      this.tail = null;
    }

    /**
     * 尾插
     *
     * @param node 要被插入的节点
     */
    public void addLast(Node node) {
      if (this.size == 0) {
        // 空链表，则node节点插入后，即为头、尾节点
        this.head = node;
        this.tail = node;
      } else {
        // 非空链表，则node节点插入到tail节点后面
        this.tail.next = node;
        node.prev = this.tail;
        this.tail = node;
      }
      this.size++;
    }

    /**
     * 删除指定节点
     *
     * @param node 要删除的节点
     */
    public void remove(Node node) {
      // 空链表没有节点，所以无法删除
      if (this.size == 0) return;

      if (this.size == 1) {
        // 链表只有一个节点，则删除完后，变为空链表
        this.head = null;
        this.tail = null;
      } else if (this.head == node) {
        // 如果要删除的节点是头节点
        this.head = this.head.next;
        this.head.prev = null;
      } else if (this.tail == node) {
        // 如果要删除的节点是尾节点
        this.tail = this.tail.prev;
        this.tail.next = null;
      } else {
        // 如果要删除的节点是中间节点
        node.prev.next = node.next;
        node.next.prev = node.prev;
      }

      this.size--;
    }
  }

  /** keyMap用于记录key对应的node */
  HashMap<Integer, Node> keyMap;

  /** freqMap的key是访问次数，value是具有相同访问次数的key对应的node组成的链表，链表头是最远访问的，链表尾是最近访问的 */
  HashMap<Integer, Link> freqMap;

  /** LFU缓存中能记录的最多key的数量 */
  int capacity;

  /** LFU缓存中所有的key中最少的访问次数 */
  int minFreq;

  public LFUCache(int capacity) {
    this.keyMap = new HashMap<>();
    this.freqMap = new HashMap<>();
    this.capacity = capacity;
    this.minFreq = 0;
  }

  public int get(int key) {
    if (this.keyMap.containsKey(key)) {
      // 存在对应key，则返回对应val
      Node node = this.keyMap.get(key);
      incNodeFreq(node); // get操作会新增对应key的访问次数
      return node.val;
    } else {
      // 不存在对应key，则返回-1
      return -1;
    }
  }

  public void put(int key, int value) {
    // 对应key已存在，则为更新场景
    if (this.keyMap.containsKey(key)) {
      Node node = this.keyMap.get(key);
      incNodeFreq(node); // 更新操作会增加对应key的访问次数
      node.val = value;
    }
    // 对应key不存在，则为新增场景
    else {
      // 先判断容量是否超过，keyMap的key数量就是LFU缓存中记录的key数量
      if (this.keyMap.size() >= this.capacity) {
        Link link = this.freqMap.get(this.minFreq);
        int removeKey = link.head.key;
        link.remove(link.head); // 最少访问次数所在链表的头节点，即为：最少、最远访问的key，容量不足时，需要优先删除它
        this.keyMap.remove(removeKey); // 注意，不要遗漏将keyMap中该key删除
      }

      // 新增key，则对应key的访问次数为1，且为最少访问次数
      this.minFreq = 1;
      Node node = new Node(key, value, this.minFreq);

      // 将新增key对应的node加入到freqMap，和keyMap中
      this.freqMap.putIfAbsent(this.minFreq, new Link());
      this.freqMap.get(this.minFreq).addLast(node);
      this.keyMap.put(key, node);
    }
  }

  /**
   * 增加key的访问次数
   *
   * @param node key对应的node
   */
  public void incNodeFreq(Node node) {
    // 由于key的访问次数增加，因此要从原访问次数的链表中删除
    this.freqMap.get(node.freq).remove(node);

    // 如果原链表删除当前key对应的节点后为空，且原链表对应的访问次数就是最少访问次数
    if (this.freqMap.get(node.freq).size == 0 && node.freq == this.minFreq) {
      // 则最少访问次数对应的key没有了，因此最少访问次数++（即当前key访问次数++后，当前key的访问次数还是最少访问次数）
      this.minFreq++;
    }

    // 当前key访问次数++
    node.freq++;

    // 将当前key对应的node转移到对应增加后的访问次数对应的链表尾部（最近访问）
    this.freqMap.putIfAbsent(node.freq, new Link());
    this.freqMap.get(node.freq).addLast(node);
  }
}

JS算法源码

/** 双向链表节点 */
class Node {
  constructor(key, val, freq) {
    /** 记录本题的键 */
    this.key = key;
    /** 记录本题的值 */
    this.val = val;
    /** 记录该键被访问的次数 */
    this.freq = freq;
    /** 当前节点的上一个节点 */
    this.prev = null;
    /** 当前节点的下一个节点 */
    this.next = null;
  }
}

/** 双向链表 */
class Link {
  constructor() {
    /** 链表中节点个数 */
    this.size = 0;
    /** 链表头节点 */
    this.head = null;
    /** 链表尾节点 */
    this.tail = null;
  }

  /**
   * 尾插
   * @param {*} node 要被插入的节点
   */
  addLast(node) {
    if (this.size == 0) {
      // 空链表，则node节点插入后，即为头、尾节点
      this.head = node;
      this.tail = node;
    } else {
      // 非空链表，则node节点插入到tail节点后面
      this.tail.next = node;
      node.prev = this.tail;
      this.tail = node;
    }
    this.size++;
  }

  /**
   * 删除指定节点
   * @param {*} node 要删除的节点
   */
  remove(node) {
    // 空链表没有节点，所以无法删除
    if (this.size == 0) return;

    if (this.size == 1) {
      // 链表只有一个节点，则删除完后，变为空链表
      this.head = null;
      this.tail = null;
    } else if (this.head == node) {
      // 如果要删除的节点是头节点
      this.head = this.head.next;
      this.head.prev = null;
    } else if (this.tail == node) {
      // 如果要删除的节点是尾节点
      this.tail = this.tail.prev;
      this.tail.next = null;
    } else {
      // 如果要删除的节点是中间节点
      node.prev.next = node.next;
      node.next.prev = node.prev;
    }

    this.size--;
  }
}

/**
 * @param {number} capacity
 */
var LFUCache = function (capacity) {
  /** keyMap用于记录key对应的node */
  this.keyMap = new Map();
  /** freqMap的key是访问次数，value是具有相同访问次数的key对应的node组成的链表，链表头是最远访问的，链表尾是最近访问的 */
  this.freqMap = new Map();
  /** LFU缓存中能记录的最多key的数量 */
  this.capacity = capacity;
  /** LFU缓存中所有的key中最少的访问次数 */
  this.minFreq = 0;
};

/**
 * @param {number} key
 * @return {number}
 */
LFUCache.prototype.get = function (key) {
  if (this.keyMap.has(key)) {
    // 存在对应key，则返回对应val
    const node = this.keyMap.get(key);
    this.incNodeFreq(node); // get操作会新增对应key的访问次数
    return node.val;
  } else {
    // 不存在对应key，则返回-1
    return -1;
  }
};

/**
 * @param {number} key
 * @param {number} value
 * @return {void}
 */
LFUCache.prototype.put = function (key, value) {
  // 对应key已存在，则为更新场景
  if (this.keyMap.has(key)) {
    const node = this.keyMap.get(key);
    this.incNodeFreq(node); // 更新操作会增加对应key的访问次数
    node.val = value;
  }
  // 对应key不存在，则为新增场景
  else {
    // 先判断容量是否超过，keyMap的key数量就是LFU缓存中记录的key数量
    if (this.keyMap.size >= this.capacity) {
      const link = this.freqMap[this.minFreq];
      const removeKey = link.head.key;
      link.remove(link.head); // 最少访问次数所在链表的头节点，即为最少、最远访问的key，容量不足时，需要优先删除它
      this.keyMap.delete(removeKey); // 注意，不要遗漏将keyMap中该key删除
    }

    // 新增key，则对应key的访问次数为1，且为最少访问次数
    this.minFreq = 1;

    // 将新增key对应的node加入到freqMap，和keyMap中
    const node = new Node(key, value, this.minFreq);

    if (this.freqMap[this.minFreq] == undefined) {
      this.freqMap[this.minFreq] = new Link();
    }

    this.freqMap[this.minFreq].addLast(node);
    this.keyMap.set(key, node);
  }
};

/**
 * 增加key的访问次数
 * @param {*} node key对应的node
 */
LFUCache.prototype.incNodeFreq = function (node) {
  // 由于key的访问次数增加，因此要从原访问次数的链表中删除
  this.freqMap[node.freq].remove(node);

  // 如果原链表删除当前key对应的节点后为空，且原链表对应的访问次数就是最少访问次数
  if (this.freqMap[node.freq].size == 0 && node.freq == this.minFreq) {
    // 则最少访问次数对应的key没有了，因此最少访问次数++（即当前key访问次数++后，当前key的访问次数还是最少访问次数）
    this.minFreq++;
  }

  // 当前key访问次数++
  node.freq++;

  // 将当前key对应的node转移到对应增加后的访问次数对应的链表尾部（最近访问）
  if (this.freqMap[node.freq] == undefined) {
    this.freqMap[node.freq] = new Link();
  }

  this.freqMap[node.freq].addLast(node);
};

Python算法源码

# 双向链表节点
class Node:
    def __init__(self, key, val, freq):
        """
        :param key: 记录本题的键
        :param val: 记录本题的值
        :param freq: 记录该键被访问的次数
        """
        self.key = key
        self.val = val
        self.freq = freq
        self.prev = None
        self.next = None


# 双向链表
class Link:
    def __init__(self):
        self.size = 0
        self.head = None
        self.tail = None

    def addLast(self, node):
        """
        尾插
        :param node: 要被插入的节点
        """
        if self.size == 0:
            # 空链表，则node节点插入后，即为头、尾节点
            self.head = node
            self.tail = node
        else:
            # 非空链表，则node节点插入到tail节点后面
            self.tail.next = node
            node.prev = self.tail
            self.tail = node

        self.size += 1

    def remove(self, node):
        """
        删除指定节点
        :param node: 要删除的节点
        """
        if self.size == 0:
            # 空链表没有节点，所以无法删除
            return

        if self.size == 1:
            # 链表只有一个节点，则删除完后，变为空链表
            self.head = None
            self.tail = None
        elif self.head == node:
            # 如果要删除的节点是头节点
            self.head = self.head.next
            self.head.prev = None
        elif self.tail == node:
            # 如果要删除的节点是尾节点
            self.tail = self.tail.prev
            self.tail.next = None
        else:
            # 如果要删除的节点是中间节点
            node.prev.next = node.next
            node.next.prev = node.prev

        self.size -= 1


class LFUCache(object):

    def __init__(self, capacity):
        self.keyMap = {}  # keyMap用于记录key对应的node
        self.freqMap = {}  # freqMap的key是访问次数，value是具有相同访问次数的key对应的node组成的链表，链表头是最远访问的，链表尾是最近访问的
        self.capacity = capacity  # LFU缓存中能记录的最多key的数量
        self.minFreq = 0  # LFU缓存中所有的key中最少的访问次数

    def get(self, key):
        if key in self.keyMap:
            # 存在对应key，则返回对应val
            node = self.keyMap[key]
            self.incNodeFreq(node)  # get操作会新增对应key的访问次数
            return node.val
        else:
            # 不存在对应key，则返回-1
            return -1

    def put(self, key, value):
        if key in self.keyMap:
            # 对应key已存在，则为更新场景
            node = self.keyMap[key]
            self.incNodeFreq(node)  # 更新操作会增加对应key的访问次数
            node.val = value
        else:
            # 对应key不存在，则为新增场景
            # 先判断容量是否超过，keyMap的key数量就是LFU缓存中记录的key数量
            if len(self.keyMap) >= self.capacity:
                link = self.freqMap[self.minFreq]
                removeKey = link.head.key
                link.remove(link.head)  # 最少访问次数所在链表的头节点，即为：最少、最远访问的key，容量不足时，需要优先删除它
                self.keyMap.pop(removeKey)  # 注意，不要遗漏将keyMap中该key删除

            # 新增key，则对应key的访问次数为1，且为最少访问次数
            self.minFreq = 1
            node = Node(key, value, self.minFreq)

            # 将新增key对应的node加入到freqMap，和keyMap中
            self.freqMap.setdefault(self.minFreq, Link())
            self.freqMap.get(self.minFreq).addLast(node)
            self.keyMap[key] = node

    def incNodeFreq(self, node):
        """
        增加key的访问次数
        :param node: key对应的node
        """
        # 由于key的访问次数增加，因此要从原访问次数的链表中删除
        self.freqMap[node.freq].remove(node)

        # 如果原链表删除当前key对应的节点后为空，且原链表对应的访问次数就是最少访问次数
        if self.freqMap[node.freq].size == 0 and node.freq == self.minFreq:
            # 则最少访问次数对应的key没有了，因此最少访问次数++（即当前key访问次数++后，当前key的访问次数还是最少访问次数）
            self.minFreq += 1

        # 当前key访问次数++
        node.freq += 1

        # 将当前key对应的node转移到对应增加后的访问次数对应的链表尾部（最近访问）
        self.freqMap.setdefault(node.freq, Link())
        self.freqMap[node.freq].addLast(node)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1319406.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[软件] Beyond Compare4

[软件] Beyond Compare4

界面简介 文件夹比较, 文本比较, 合并等非常有用的软件, 尤其是在对比代码上面, 有时候很难找到自己的代码和别人的代码到底哪里出现了区别, 这个软件就非常有效了.
阅读更多...
智能制造网络：连接未来制造业

智能制造网络：连接未来制造业

数字化在制造业中已经成为国家战略和行业升级的显著趋势。其影响不仅深刻地触及到个人生活&#xff0c;也在国家层面产生了重大影响&#xff0c;涉及经济、国防和军事等多个领域。在制造业数字化转型的进程中&#xff0c;构建坚实的基础网络被视为确保数字化生产全过程顺畅运作…
阅读更多...
什么胶能粘PP塑料？

什么胶能粘PP塑料？

在日常生活中或实际制造业中&#xff0c;会遇到需要将PP塑料&#xff08;聚丙烯&#xff09;与其他物质粘合的情况&#xff0c;我们会选择使用胶水来粘合。那么&#xff0c;究竟什么样的胶水能更好的粘合PP塑料呢&#xff1f; PP塑料是一种非极性材料&#xff0c;表面通常比较…
阅读更多...
【兔子王赠书第12期】赠ChatGPT中文范例的自然语言处理入门书

【兔子王赠书第12期】赠ChatGPT中文范例的自然语言处理入门书

文章目录 写在前面自然语言处理图书推荐图书简介编辑推荐 推荐理由粉丝福利写在后面 写在前面 小伙伴们好久不见吖&#xff0c;本期博主给大家推荐一本入门自然语言处理的经典图书&#xff0c;一起来看看吧~ 自然语言处理 自然语言处理&#xff08;Natural Language Process…
阅读更多...
Linux---远程登录、远程拷贝命令

Linux---远程登录、远程拷贝命令

1. 远程登录、远程拷贝命令的介绍 命令说明ssh远程登录scp远程拷贝 2. ssh命令的使用 ssh是专门为远程登录提供的一个安全性协议&#xff0c;常用于远程登录&#xff0c;想要使用ssh服务&#xff0c;需要安装相应的服务端和客户端软件&#xff0c;当软件安装成功以后就可以使…
阅读更多...
百分比组件 - elementui改动

百分比组件 - elementui改动

<el-slider v-model"value2" style"width: 87%;position: absolute;bottom: 9px;" disabled :show-tooltip"false"></el-slider>value2: 0,// 百分比条 ::v-deep .el-slider__runway.disabled .el-slider__bar {background-color: #…
阅读更多...
饥荒Mod 开发(十一)：修改物品堆叠

饥荒Mod 开发(十一)：修改物品堆叠

饥荒Mod 开发(十)&#xff1a;制作一把AOE武器 饥荒Mod 开发(十二)&#xff1a;一键制作 饥荒中物品栏有限&#xff0c;要拾取的物品有很多&#xff0c;经常装不下要忍痛丢掉各种东西&#xff0c;即使可以将物品放在仓库但是使用不方便&#xff0c;所以可以将物品的堆叠个数设…
阅读更多...
springcloud：对象存储组件MinIO

springcloud：对象存储组件MinIO

类似于FastDFS/HDFS的一个文件存储服务&#xff01; SpringBoot整合MinIO实现分布式文件服务&#xff01; #MinIO简介&#xff1f; Minio 是个基于 Golang 编写的开源对象存储套件&#xff0c;基于Apache License v2.0开源协议&#xff0c;虽然轻量&#xff0c;却拥有着不错的…
阅读更多...
低代码开发平台的优势及应用场景分析

低代码开发平台的优势及应用场景分析

文章目录 低代码是什么&#xff1f;低代码起源低代码分类低代码的能力低代码的需求市场需要专业开发者需要数字化转型需要 低代码的趋势如何快速入门低代码开发低代码应用领域 低代码是什么&#xff1f; 低代码&#xff08;Low-code&#xff09;是著名研究机构Forrester于2014…
阅读更多...
JS中的模板字符串（ES6中的模板字面量语法），什么是模板字符串、怎么使用，附代码演示

JS中的模板字符串（ES6中的模板字面量语法），什么是模板字符串、怎么使用，附代码演示

模板字符串 1、JavaScript 在 ES6 新增了模板字符串语法。模板字符串可以作为普通字符串使用&#xff0c;其作用是可以在字符串中换行&#xff08;也就是支持多行字符串&#xff09;以及将变量和表达式插入字符串。 2、整个语法&#xff1a;使用反引号 &#xff0c;而不是单引…
阅读更多...
如何绘制甘特图？

如何绘制甘特图？

甘特图(Gantt chart) 又叫横道图、条状图(Bar chait)。它是在第一次世界大战时期发明的&#xff0c;以亨利I甘特先生的名字命名&#xff0c;他制定了一个完整地用条形图表进度的标志系统。甘特图内在思想简单&#xff0c;即以图示的方式通过活动列表和时间刻度形象地表示出任何…
阅读更多...
【C++高阶(七)】C++异常处理的方式

【C++高阶(七)】C++异常处理的方式

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:C从入门到精通⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习C   &#x1f51d;&#x1f51d; 异常处理的方式 1. 前言2. C语言处理异常的方式…
阅读更多...
【密码学】群的证明（习题）

【密码学】群的证明（习题）

0.前置知识 1.习题 记录一次密码学作业~群的判定 2.求解
阅读更多...
Chrome2023新版收藏栏UI改回旧版

Chrome2023新版收藏栏UI改回旧版

版本 120.0.6099.109&#xff08;正式版本&#xff09;Chrome浏览器菜单新版、旧版的差异 想要将书签、功能内容改回旧版的朋友可以网址栏输入&#xff1a;「chrome://flags」&#xff0c;接着搜寻「Chrome Refresh 2023」。 最后将 Chrome Refresh 2023、Chrome Refresh 2023…
阅读更多...
HNU-数据库系统-实验1-数据定义/数据操纵

HNU-数据库系统-实验1-数据定义/数据操纵

数据库系统 课程实验1数据定义/数据操纵 计科210X 甘晴void 202108010XXX 目录 文章目录 数据库系统 课程实验1<br>数据定义/数据操纵实验目的实验样例实验环境实验内容1.1 数据库定义1&#xff09;实验内容与要求2&#xff09;实验重难点3&#xff09;实验基础知识①模…
阅读更多...
【JAVA-Day69】抛出异常的精髓：深度解析 throw、throws 关键字，优雅处理异常问题

【JAVA-Day69】抛出异常的精髓：深度解析 throw、throws 关键字，优雅处理异常问题

抛出异常的精髓&#xff1a;深度解析 throw、throws 关键字&#xff0c;优雅处理异常问题 &#x1f680; 抛出异常的精髓&#xff1a;深度解析 throw、throws 关键字&#xff0c;优雅处理异常问题 &#x1f680;一、什么是抛出异常 &#x1f60a;二、如何抛出异常 &#x1f914…
阅读更多...
复合型下拉框

复合型下拉框

element只提供了复合型输入框&#xff0c;复合型下拉框的效果&#xff0c;我是通过button与el-select拼接形成的&#xff0c;代码如下&#xff1a; <div class"form"><button class"btn">是否需要审核</button><el-select v-model&q…
阅读更多...
C语言之文件操作（上）

C语言之文件操作（上）

C语言之文件操作&#xff08;上&#xff09; 文章目录 C语言之文件操作&#xff08;上&#xff09;1. 什么是⽂件&#xff1f;1.1 程序⽂件1.2 数据⽂件1.3 ⽂件名 2. ⼆进制⽂件和⽂本⽂件3. ⽂件的打开和关闭3.1 流和标准流3.1.1 流3.1.2 标准流 4. ⽂件指针5. 文件的打开与关…
阅读更多...
c语言：制造简单的计算器｜练习题

c语言：制造简单的计算器｜练习题

一、题目 制造一个简单的计算器。输入两个数&#xff0c;计算加减乘除的结果。 如图&#xff1a; 二、代码截图【带注释】 三、源代码【带注释】 #include int main() { int yunSuanFu0;//定义运算符符号变量 int num1,num2;//定义要输入的两个数字 cc: printf(…
阅读更多...
VUE中的8种常规通信方式

VUE中的8种常规通信方式

文章目录 1.props传递数据(父向子)2.$emit触发自定义事件&#xff08;子向父&#xff09;3.ref&#xff08;父子&#xff09;4.EventBus&#xff08;兄弟组件&#xff09;5.parent或root&#xff08;兄弟组件&#xff0c;有共同祖辈&#xff09;6.attrs和listeners&#xff08;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023