目录
有关链表的其他算法题,可以参考我上篇写的文章经典算法之链表篇(二)
一:旋转链表(LeetCode.61)
问题描述:
给你一个链表的头节点
head
,旋转链表,将链表每个节点向右移动k
个位置。
示例:
输入:head = [1,2,3,4,5], k = 2
输出:[4,5,1,2,3]
解题思路:
计算链表的长度,并找到链表的尾节点,同时将链表形成一个循环链表。
计算实际需要移动的步数
k = k % 链表长度
,因为如果k
大于链表长度,实际上是重复一整轮的旋转操作。找到新链表的尾节点和头节点的位置,并将尾节点指向
nullptr
,形成新的链表。
图示:
第一步:
第二步:
第三步:
第四步:
代码演示:
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if (head == null || k == 0) return head;
// 计算链表长度并找到尾节点
int len = 1;
ListNode tail = head;
while (tail.next != null) {
tail = tail.next;
len++;
}
// 计算实际需要旋转的次数
k = k % len;
if (k == 0) return head; // 如果 k 是链表长度的倍数,不需要旋转
// 找到倒数第 k+1 个节点,作为新的尾节点
ListNode newTail = head;
for (int i = 0; i < len - k - 1; i++) {
newTail = newTail.next;
}
// 旋转链表
ListNode newHead = newTail.next;
newTail.next = null; // 断开环
tail.next = head; // 将原链表接到尾部
return newHead;
}
}
二:LRU缓存(LeetCode.146)
问题描述:
请你设计并实现一个满足 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)
的平均时间复杂度运行。
示例:
输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
解题思路:
定义双向链表节点结构体
DLinkedNode
,包含key
、value
、pre
(前驱指针)和next
(后继指针)四个成员变量。定义LRUCache类,私有成员变量包括一个哈希表
cache
(用于存储key到节点的映射)、头指针head
(指向双向链表的头部哨兵节点)、尾指针tail
(指向双向链表的尾部哨兵节点)、当前缓存节点数量size
和缓存容量capacity
。LRUCache构造函数初始化容量
capacity
和size
为0,创建头部和尾部哨兵节点,并连接头尾节点。
get
方法先判断key是否存在于哈希表中,如果不存在则返回-1;如果存在,则从哈希表中获取对应节点,并将该节点移动至双向链表头部,最后返回节点的值。
put
方法先判断key是否存在于哈希表中,如果不存在则创建一个新节点,并将节点添加至双向链表头部,更新哈希表映射,并判断缓存是否超过容量,如果超过则删除双向链表尾部节点和哈希表映射;如果存在则更新节点值,并将节点移动至双向链表头部。私有方法
addToHead
用于将节点添加至双向链表头部,removeNode
用于移除指定节点,moveToHead
用于将指定节点移动至双向链表头部,removeTail
用于移除双向链表尾部节点并返回该节点。
代码演示:
import java.util.*;
class LRUCache {
private int capacity;
private Map<Integer, Node> cache;
private Node head;
private Node tail;
// 定义双向链表节点
private class Node {
int key;
int value;
Node prev;
Node next;
Node(int key, int value) {
this.key = key;
this.value = value;
}
}
// 初始化LRU Cache
public LRUCache(int capacity) {
this.capacity = capacity;
cache = new HashMap<>();
head = new Node(-1, -1); // 哨兵节点,不存储数据
tail = new Node(-1, -1); // 哨兵节点,不存储数据
head.next = tail;
tail.prev = head;
}
// 获取key对应的value,并将节点移到链表头部
public int get(int key) {
if (!cache.containsKey(key)) {
return -1;
}
Node node = cache.get(key);
moveToHead(node);
return node.value;
}
// 存入key-value键值对,如果key已存在则更新value,并将节点移到链表头部;否则插入新节点,并移除最近最少使用的节点
public void put(int key, int value) {
if (cache.containsKey(key)) {
Node node = cache.get(key);
node.value = value;
moveToHead(node);
} else {
Node newNode = new Node(key, value);
cache.put(key, newNode);
addToHead(newNode);
if (cache.size() > capacity) {
Node tailNode = removeTail();
cache.remove(tailNode.key);
}
}
}
// 将节点添加到链表头部
private void addToHead(Node node) {
node.prev = head;
node.next = head.next;
head.next.prev = node;
head.next = node;
}
// 移除节点
private void removeNode(Node node) {
node.prev.next = node.next;
node.next.prev = node.prev;
}
// 将节点移到链表头部
private void moveToHead(Node node) {
removeNode(node);
addToHead(node);
}
// 移除链表尾部节点
private Node removeTail() {
Node tailNode = tail.prev;
removeNode(tailNode);
return tailNode;
}
public static void main(String[] args) {
LRUCache cache = new LRUCache(2);
cache.put(1, 1);
cache.put(2, 2);
System.out.println(cache.get(1)); // 返回 1
cache.put(3, 3); // 该操作会使得关键字 2 作废
System.out.println(cache.get(2)); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得关键字 1 作废
System.out.println(cache.get(1)); // 返回 -1 (未找到)
System.out.println(cache.get(3)); // 返回 3
System.out.println(cache.get(4)); // 返回 4
}
}
总结:
以上的两道链表题是比较常考的,在力扣的难度都为中等,因此要多理解,下一期将继续更新有关力扣的算法题。