leetcode刷题 | O(1) 时间插入、删除和获取随机元素的容器和LRUCache类_下面哪个容器支持在中间插入和删除元素的时间复杂度为o(1)-CSDN博客

本文链接：https://blog.csdn.net/qq_43167873/article/details/128864282

文章讲述了如何使用HashMap+ArrayList实现一个支持O(1)时间复杂度的插入、删除和获取随机元素的容器，并利用HashMap+双向链表实现LRUCache类，满足O(1)的get和put操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

leetcode刷题 | O(1) 时间插入、删除和获取随机元素的容器和LRUCache类

文章目录

leetcode刷题 | O(1) 时间插入、删除和获取随机元素的容器和LRUCache类

O(1) 时间插入、删除和获取随机元素的容器

题目要求

链接：380. O(1) 时间插入、删除和获取随机元素 - 力扣（LeetCode）

设计一个支持在平均时间复杂度 O(1) 下，执行以下操作的数据结构：

insert(val)：当元素 val 不存在时返回 true ，并向集合中插入该项，否则返回 false 。
remove(val)：当元素 val 存在时返回 true ，并从集合中移除该项，否则返回 false 。
getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。

数据结构选择

题目要求实现插入、删除和随机访问的时间复杂度均为O(1)的容器。

为了实现在O(1)时间获取元素,可以采用数组,由于还需要插入和删除的操作所以需要使用可变长数组ArrayList；但是题目还要求插入和删除的时间都为O(1),可以实现的的数据结构为HashMap,HashMap插入和删除元素的时间复杂度均为O(1),由此可以得知该题目的数据结构为HashMap+ArrayList；

具体实现步骤

HashMap用来存储val和val在数组中的位置，ArrayList用来存储val值

HashMap - map

ArrayList - list

size 为数组的大小

插入操作：

首先判断val是否在map中,如果存在返回false；
如果不存在，在list末尾添加val；
把val和其下标size存入到map中;
size++,更新大小

删除操作：

首先判断val是否在map中，如果不存在返回false；
如果存在，首先从map中获取val的index；
将最后一个元素last移动到index位置，并将map中的last下标更新为index，这么做的时间复杂度为O(1)，并且可以保证数组的下标是连续的
将list最后一个元素删除，在map中删除val
size --；

随机获取：

新建一个Random类,直接返回list.get(rand.nextInt(size));

class RandomizedSet {
    HashMap<Integer,Integer> map;
    int size;
    ArrayList<Integer> list;
    Random rand = new Random();
    /** Initialize your data structure here. */
    public RandomizedSet() {
       map = new HashMap();
       list = new ArrayList();
       size = 0;
    }

    public boolean insert(int val) {
        if(map.containsKey(val)) return false;
        map.put(val,size);
        list.add(val);
        size++;
        return true;

    }

    public boolean remove(int val) {
        if(!map.containsKey(val)) return false;
        int index = map.get(val);
        int last = list.get(size-1);
        list.set(index,last);
        map.put(last,index);
        map.remove(val);
        list.remove(size-1);
        size --;
        return true;
    }

    public int getRandom() {
        return list.get(rand.nextInt(size));
    }
}

LRUCache类

题目要求

链接：146. LRU 缓存 - 力扣（LeetCode）

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

数据结构选择

LRU算法是一种缓存淘汰策略，一般情况下缓存容量是有限的，如果缓存满了那么久要删除一些不常用的内容，LRU算法认为最近使用的数据是有用的数据，很久没有用的数据是无用的数据，在缓存不足的情况下应该删除。

题目要求get和put的时间复杂度均为O(1),根据上一题的经验可以得知HashMap可以实现插入和删除的时间复杂度均为O(1),但是其数据没有固定的顺序，这样无法直接找到哪些是有用的数据，哪些是无用的数据；链表具有固定的顺序但是插入和删除的时间复杂度不符合题意，所以可以结合一下作为本题的数据结构：HashMap+双向链表

链表采用双向链表的原因是，在题目中需要涉及到删除操作，需要得到删除元素的前驱节点，双向链表可以直接查找到前驱节点

具体实现步骤

可以自己创建一个双向链表类，可以直接用java提供的LinkedHashMap

   class DLinkedNode{
        int key;
        int val;
        DLinkedNode next;
        DLinkedNode prev;
        public DLinkedNode(){}
        public DLinkedNode(int key,int val){
            this.val = val;
            this.key = key;
        }
    }

在实现LRU之前，需要实现关于链表的几个方法:

addToHead 添加到头节点
removeNode 删除该节点
moveToHead 将该节点移动到头节点
removeTail 删除尾节点

    public void addtoHead(DLinkedNode temp){
        temp.next = head.next;
        head.next.prev = temp;
        head.next = temp;
        temp.prev = head;
        
    }
    public void removeNode(DLinkedNode node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    public void moveoHead(DLinkedNode node){
        removeNode(node);
        addtoHead(node);
    }
    public DLinkedNode removeTail(){
        tail.prev.next = head;
        head.prev = tail.prev;
        tail= tail.prev;
        return tail;
    }

接下来进行初始化：

    private DLinkedNode head,tail;
    private int size;
    private int capacity;
    private HashMap<Integer,DLinkedNode> map = new HashMap();;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

设定一个伪头节点和伪尾节点来作为维护链表

get操作：

首先判断map中是否包含key，如果不存在返回-1
存在，通过map找到key所对应的node节点
并将该node节点移动到链表的头部
返回node.val

put操作：

判断map中是否包含key，如果不存在，创建一个新的节点，并将该节点添加到链表的头部，map中存储该节点的key和node
然后判断链表容量是否超过size大小，超过则将链表的尾节点删除，并删除map中对应的元素
如果存在，将node.val进行更新，并将node移动到头部

class LRUCache {
    class DLinkedNode{
        int key;
        int val;
        DLinkedNode next;
        DLinkedNode prev;
        public DLinkedNode(){}
        public DLinkedNode(int key,int val){
            this.val = val;
            this.key = key;
        }

    }
    private DLinkedNode head,tail;
    private int size;
    private int capacity;
    private HashMap<Integer,DLinkedNode> map = new HashMap();;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        DLinkedNode temp = map.get(key);
        if(temp == null) return -1;
        movetoHead(temp);
        return temp.val;
    }
    
    public void put(int key, int value) {
        DLinkedNode node = map.get(key);
        if(node == null){
            node = new DLinkedNode(key,value);
            addtoHead(node);
            map.put(key,node);
            size ++;
            if(capacity < size){
                DLinkedNode tail = removeTail();
                map.remove(tail.key);
                size --;
            }
        }else{
            node.val = value;
            movetoHead(node);
        }
    }
    public void addtoHead(DLinkedNode temp){
        temp.next = head.next;
        head.next.prev = temp;
        head.next = temp;
        temp.prev = head;
        
    }
    public void removeNode(DLinkedNode node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    public void movetoHead(DLinkedNode node){
        removeNode(node);
        addtoHead(node);
    }
    public DLinkedNode removeTail(){
        tail.prev.next = head;
        head.prev = tail.prev;
        tail= tail.prev;
        return tail;
    }
}

import java.util.LinkedHashMap;

public class LRUCache {
    int capacity;
    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
    public LRUCache(int capacity) {
        this.capacity = capacity;
    }

    public int get(int key) {
        if (!cache.containsKey(key)) {
            return -1;
        }
        moeToHead(key);
        return cache.get(key);
    }

    public void put(int key, int val) {
        if (cache.containsKey(key)) {
            cache.put(key, val);
            moeToHead(key);
            return;
        }

        if (cache.size() >= this.capacity) {
            int oldestKey = cache.keySet().iterator().next();
            cache.remove(oldestKey);
        }
        cache.put(key, val);
    }

    private void moeToHead(int key) {
        int val = cache.get(key);
        cache.remove(key);
        cache.put(key, val);
    }
}