目录
理论基础
单链表
-
链表反转：将链表中的指针方向反转，使得链表从头到尾的顺序变为从尾到头。
- 迭代法（用指针依次翻转节点）或递归法（从后往前递归反转）。
-
删除链表中的节点：给定链表中的一个节点，删除该节点。
- 如果是删除给定节点，调整指针指向下一个节点。
-
删除倒数第 N 个节点：删除链表中从倒数第 N 个位置的节点。
- 使用双指针（快慢指针），先让一个指针走 N 步，随后两个指针一起走，直到快指针到达链表末尾时，慢指针指向的就是要删除的节点。
-
合并两个有序链表：将两个有序链表合并为一个有序链表。
- 迭代比较每个链表的头节点，依次连接到新链表。
-
链表排序：对无序链表进行排序。
- 归并排序较为常见，先将链表分成两部分，对每部分排序后再合并。
双链表
-
插入节点：在双链表中间插入一个新节点。
- 根据节点的前后指针更新链表中的节点指向。
-
删除节点：从双链表中删除一个指定节点。
- 需要更新被删除节点前后两个节点的指针。
-
反转双链表：将双链表反转。
- 遍历链表，将每个节点的前后指针交换。
-
合并两个双链表：将两个双链表合并成一个。
- 与单链表类似，根据节点的大小逐一合并，同时注意更新前后指针。
环形链表
-
是否有环
- 使用快慢指针法，快指针每次走两步，慢指针每次走一步，如果两者相遇，说明链表中有环。
-
寻找环的入口
- 当快慢指针相遇后，重新从头开始一个指针，两个指针同步前进，相遇的地方即为环的入口。
-
环的长度：计算链表环的长度。
- 在快慢指针相遇后，继续前进一圈直到回到相遇点，计算这段路径的长度。
合并链表
-
合并 K 个有序链表
- 使用优先队列（最小堆）法，将每个链表的最小值逐步取出并连接，直到所有链表合并完毕。
-
链表交叉：判断两个链表是否有交点，并找到第一个交点。
- 使用双指针，分别从两个链表的头节点出发，走到链表末尾后换到另一个链表的头节点，最终两个指针相遇时即为交点。
其他
-
重排链表：将链表重排为前半部分和反转后的后半部分交替出现的顺序。
- 找到链表的中点，反转后半部分，再将前后两部分交替合并。
-
链表的中点：找到链表的中间节点。
- 使用快慢指针法，快指针每次走两步，慢指针每次走一步，快指针到达末尾时，慢指针就是链表的中点。
-
链表旋转：将链表向右旋转 K 个位置。
- 先将链表闭合成环，然后找到新的头节点，断开环形成新的链表。
-
链表与栈：在某些题目中，链表可以结合栈来解决问题，比如逆序遍历链表时，可以借助栈将节点存储后再逐个弹出。
- 链表的回文判断。通过栈保存前半部分，比较后半部分。
-
链表与哈希表：有时为了加速查找链表中的元素或节点，可以结合哈希表来存储已经遍历过的节点信息。
- 判断链表是否有环，或在链表中快速查找某个节点。
总结
- 快慢指针 是解决链表问题的常用技巧，适用于找中点、判断环、找倒数节点等。
- 递归与迭代 是处理链表反转、合并和排序等问题的经典方法。
- 优先队列（堆） 常用于处理多条有序链表合并的问题。
- 双指针法 能高效处理合并链表、查找链表交点、删除倒数节点等问题。
160.相交
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
自定义评测：
评测系统 的输入如下（你设计的程序 不适用 此输入）：
intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。
1
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。
2
输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
3
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]
进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？
两个链表分别走完自己后切换到对方的链表时，由于总长度相同，它们会同步到达交点或同时为 null，因此第一次相遇的节点就是链表的交点
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) {
return null;
}
ListNode pointerA = headA;
ListNode pointerB = headB;
// 双指针遍历，若有交点，最终会在交点相遇；否则会同时到达 null
while (pointerA != pointerB) {
// 当 pointerA 到达末尾时，跳到 headB 开始遍历，pointerB 同理
pointerA = (pointerA == null) ? headB : pointerA.next;
pointerB = (pointerB == null) ? headA : pointerB.next;
}
// 返回相交的节点，若无相交，最终会是 null
return pointerA;
}
}
调整两个指针，使它们从长度较长的链表的头部开始，且最终同时到达交点或同时到达null
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null) {
return null;
}
ListNode pointerA = headA;
ListNode pointerB = headB;
int lengthA = getLength(pointerA);
int lengthB = getLength(pointerB);
// 调整两个指针，使它们从长度较长的链表的头部开始，且最终同时到达交点或同时到达null
if (lengthA > lengthB) {
for (int i = 0; i < lengthA - lengthB; i++) {
pointerA = pointerA.next;
}
} else {
for (int i = 0; i < lengthB - lengthA; i++) {
pointerB = pointerB.next;
}
}
while (pointerA != null && pointerB != null) {
if (pointerA == pointerB) {
return pointerA;
}
pointerA = pointerA.next;
pointerB = pointerB.next;
}
return null; // 没有相交
}
private int getLength(ListNode node) {
int length = 0;
while (node != null) {
length++;
node = node.next;
}
return length;
}
}206.反转
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
1
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
2
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000class Solution {
public ListNode reverseList(ListNode head) {
ListNode cur=head,pre=null,t=null;
while(cur!=null){
t=cur.next;
cur.next=pre;
pre=cur;//已经断了
cur=t;
}
return pre;//反过来了
}
}自己动手画图！
234.回文
给你一个单链表的头节点 head ，请你判断该链表是否为
回文链表
。如果是，返回 true ；否则，返回 false 。
输入：head = [1,2,2,1]
输出：true
输入：head = [1,2]
输出：false
提示：
链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9
思路:回文链表，以链表中间为中心点两边对称
—>两个指针同时往中间靠，判断所指的字符是否相等
—>单向链表，所以把链表后半部分反转
—>后半部分，快慢指针找出中间点
class Solution {
public boolean isPalindrome(ListNode head) {
ListNode f = head, s = head;
// 通过快慢指针找到中点
while (f != null && f.next != null) {
f = f.next.next;
s = s.next;
}
// 如果f不为空，说明链表的长度是奇数个
if (f != null) s = s.next;
s = reverse(s);
f = head;
while (s != null) {//判断节点值是否相等
if (f.val != s.val) return false;
f = f.next;
s = s.next;
}
return true;
}
// 反转链表
public ListNode reverse(ListNode head) {
ListNode p = null;
while (head != null) {
ListNode next = head.next;
head.next = p;
p = head;
head = next;
}
return p;
}
}
用栈
class Solution {
public boolean isPalindrome(ListNode head) {
ListNode t = head;
Stack<Integer> s = new Stack();
while (t != null) { //把链表节点的值存放到栈中
s.push(t.val);
t = t.next;
}
while (head != null) {//出栈
if (head.val != s.pop()) return false;
head = head.next;
}
return true;
}
}
141.环形
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
1
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
2
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
3
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
提示：
链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。
进阶：你能用 O(1)（即，常量）内存解决此问题吗？
class Solution {
public boolean hasCycle(ListNode head) {
ListNode s = head, f = head;
while (f != null && f.next != null) {
s = s.next;
f = f.next.next;
if (f==s) return true;
}
return false;
}
}
142.环形2
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
1
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
2
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
3
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
进阶：你是否可以使用 O(1) 空间解决此题？
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode f=head,s=head;
while(f!=null&&f.next!=null){
f=f.next.next;
s=s.next;
if(s==f){
ListNode p1=f,p2=head;
while(p1!=p2){
p1=p1.next;
p2=p2.next;
}
return p1;
}
}
return null;//别忘了
}
}21.合并有序
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode d= new ListNode(0), cur=d;
while(l1!=null && l2!=null){
if(l1.val<l2.val){
cur.next=l1;
l1=l1.next;
}else{
cur.next=l2;
l2=l2.next;
}
cur=cur.next;
}
cur.next=(l1!=null)?l1:l2;//记得加上剩余部分
return d.next;
}
}2.两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
进位：和大于等于 10 时，需要把超过 10 的部分“进位”到下一位
public class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode d= new ListNode(0),c=d;
int n=0;
while(l1!=null || l2!=null|| n!=0) {
int sum=(l1==null?0:l1.val)+(l2==null?0:l2.val)+n;//处理某个链表到末尾
n=sum/10;//比如14的1
c.next = new ListNode(sum % 10); //比如14的4
c=c.next;
if (l1!=null) l1=l1.next;
if (l2!=null) l2=l2.next;
}
return d.next;
}
}
19.删除倒数第N个
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
进阶：你能尝试使用一趟扫描实现吗？
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode d=new ListNode(0);
d.next=head;
ListNode f=d,s=d;
while(n--!=0) f=f.next;
while(f.next!=null){
f=f.next;
s=s.next;
}
s.next=s.next.next;
return d.next;
}
}24.两两交换
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode d= new ListNode(0);
d.next = head;
ListNode t=d;
while(t.next != null && t.next.next != null) {
ListNode s= t.next;
ListNode f= t.next.next;
t.next=f;
s.next=f.next;
f.next =s;
t= s;
}
return d.next;
}
}自己去画图
递归法
class Solution {
public ListNode swapPairs(ListNode a) {
if (a == null || a.next == null) return a; // 终止条件
ListNode b = a.next; // b 指向 a 的下一个节点
a.next = swapPairs(b.next); // 递归处理 b 后面的节点，连接到 a 的 next
b.next = a; // 让 b 的 next 指向 a，交换位置
return b; // 返回 b，作为新的一对中第一个节点
}
}
25.K个一组翻转h
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000
进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？
感觉和哪道题有点像来着，有个字符串好像也是这么翻转
public class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
// 判断剩余节点是否小于 k：找到前 k 个节点
ListNode tail = head;
for (int i = 0; i < k; i++) {
if (tail == null) return head;//终止条件
tail = tail.next;
}
// 反转前 k 个节点
ListNode newHead = reverse(head, tail);
// 对剩余的链表进行递归反转，并将反转后的部分连接到当前的链表上
head.next = reverseKGroup(tail, k);
return newHead;
}
//老生常谈的反转
private ListNode reverse(ListNode head, ListNode tail) {
ListNode pre = null, next = null;
while (head != tail) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
}138.随机复制
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。
返回复制链表的头节点。
用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：
val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。
提示：
0 <= n <= 1000
-104 <= Node.val <= 104
Node.random 为 null 或指向链表中的节点。
随机，那就哈希
哈希表的 key 是原链表中的节点，value 是新链表的节点
然后设置新链表中节点的 next 和 random 指针
class Solution {
public Node copyRandomList(Node head) {
if(head == null) return null;
Node cur = head;
Map<Node, Node> map = new HashMap<>();
// 复制各节点，并建立 “原节点 -> 新节点” 的 Map 映射
while(cur != null) {
map.put(cur, new Node(cur.val));
cur = cur.next;
}
cur = head;
//构建新链表的 next 和 random 指向
while(cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).random = map.get(cur.random);
cur = cur.next;
}
return map.get(head);
}
}148.排序
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
提示：
链表中节点的数目在范围 [0, 5 * 104] 内
-105 <= Node.val <= 105
进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
归并
递归
class Solution {
public ListNode sortList(ListNode head) {
if (head == null || head.next == null) return head;//终止条件
// 使用快慢指针找到链表的中间节点
ListNode slow = head, fast = head.next;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
// 切断链表
ListNode mid = slow.next;
slow.next = null;
// 递归地排序两个部分
ListNode left = sortList(head);
ListNode right = sortList(mid);
// 合并两个排序好的链表
return merge(left, right);
}
private ListNode merge(ListNode left, ListNode right) {
ListNode dummy = new ListNode(0);
ListNode tail = dummy;
// 比较两个链表的节点，按顺序合并
while (left != null && right != null) {
if (left.val < right.val) {
tail.next = left;
left = left.next;
} else {
tail.next = right;
right = right.next;
}
tail = tail.next;
}
// 将剩余的节点接到合并链表的末尾
tail.next = (left != null) ? left : right;
return dummy.next;
}
}
23.合并K个升序h
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4最小堆又来了
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);//最小堆
// 把所有链表的头节点（不为空的）加入到优先队列中
for (ListNode head : lists)
if (head != null) pq.offer(head);
// 创建一个用来合并链表的起点
ListNode dummy = new ListNode();
// cur合并链表的终点
ListNode cur = dummy;
while (!pq.isEmpty()) {
ListNode node = pq.poll();// 从优先队列中取出值最小的节点
if (node.next != null) pq.offer(node.next);
cur.next = node;// 将取出的节点连接到合并链表的最后
cur = cur.next;// 更新 cur
}
return dummy.next;
}
}
为什么这道题是Hard呢
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) 的平均时间复杂度运行。
示例：
输入
["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
提示：
1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put
class LRUCache {
private static class Node {
int key, value;
Node prev, next;
Node(int k, int v) {
key = k;
value = v;
}
}
private final int capacity;
private final Node dummy = new Node(0, 0); // 哨兵节点
private final Map<Integer, Node> keyToNode = new HashMap<>();
public LRUCache(int capacity) {
this.capacity = capacity;
dummy.prev = dummy;
dummy.next = dummy;
}
public int get(int key) {
Node node = getNode(key);
return node != null ? node.value : -1;
}
public void put(int key, int value) {
Node node = getNode(key);
if (node != null) { // 有这本书
node.value = value; // 更新 value
return;
}
node = new Node(key, value); // 新书
keyToNode.put(key, node);
pushFront(node); // 放在最上面
if (keyToNode.size() > capacity) { // 书太多了
Node backNode = dummy.prev;
keyToNode.remove(backNode.key);
remove(backNode); // 去掉最后一本书
}
}
private Node getNode(int key) {
if (!keyToNode.containsKey(key)) { // 没有这本书
return null;
}
Node node = keyToNode.get(key); // 有这本书
remove(node); // 把这本书抽出来
pushFront(node); // 放在最上面
return node;
}
// 删除一个节点（抽出一本书）
private void remove(Node x) {
x.prev.next = x.next;
x.next.prev = x.prev;
}
// 在链表头添加一个节点（把一本书放在最上面）
private void pushFront(Node x) {
x.prev = dummy;
x.next = dummy.next;
x.prev.next = x;
x.next.prev = x;
}
}
扫一扫
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
