【数据结构与算法】链表模板及例题
2021-09-23 21:59
931 查看
链表模板
链表结构
public class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } }
虚拟头节点
虚拟头节点用于是链表每一个节点都具有前一个节点,结构统一,可以规避特殊情况,使得链表头节点也可以当作普通节点处理。
ListNode dummy = new ListNode(-1); dummy.next = head; /**********/ return dummy.next;
获取链表倒数第k个节点
ListNode dummy = new ListNode(-1); dummy.next = head; //虚拟头节点 ListNode l = dummy; //l是慢指针,指向虚拟头节点 ListNode r = dummy; //r是快指针,指向虚拟头节点 for (int i = 0; i < k; i++) { r = r.next; //快指针移动k次 } while (r != null) { l = l.next; r = r.next; } // l所指向的节点就是链表倒数第k个节点
链表节点交换
ListNode tmp = pos.next; pos.next = cur; cur.next = tmp; pre.next = pos;
链表反转
整个链表反转
public ListNode reverseList(ListNode head) { if(head == null || head.next == null) return head; ListNode dummy = new ListNode(-1); dummy.next = head; ListNode pre = dummy; ListNode cur = dummy.next; while(cur != null) { ListNode tmp = cur.next; cur.next = pre; pre = cur; cur = tmp; } dummy.next.next = null; dummy.next = pre; return dummy.next; }
链表局部反转
翻转链表从left到right范围内的节点
比如:翻转第2到第4个节点之间的链表
public ListNode reverseBetween(ListNode head, int left, int right) { int length = right - left + 1; //一共要反转length个节点 ListNode dummy = new ListNode(-1); dummy.next = head; ListNode hh = dummy; //hh指向目标反转范围的前一个节点 while(left-- > 1) { hh = hh.next; } ListNode a = hh.next, b = a.next; while(length-- > 1) { //一共要反转length个节点, 中间就有 length - 1 个 next 指针需要翻转 ListNode tmp = b.next; b.next = a; a = b; b = tmp; } hh.next.next = b; hh.next = a; return dummy.next; }
双向链表
🌈 节点:
class Node{ int k,v; Node l,r; Node(int key, int value){ this.k = key; this.v = value; } }
🌈 虚拟头尾节点
🌈 双向链表节点的插入
target.r = node.r; node.r.l = target; target.l = node; node.r = target
🌈 双向链表节点的删除
node.r.l = node.l; node.l.r = node.r;
例题
两数相加
给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。 请你将两个数相加,并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外,这两个数都不会以 0 开头。 示例 1: 输入:l1 = [2,4,3], l2 = [5,6,4] 输出:[7,0,8] 解释:342 + 465 = 807. 示例 2: 输入:l1 = [0], l2 = [0] 输出:[0] 示例 3: 输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9] 输出:[8,9,9,9,0,0,0,1] 提示: 每个链表中的节点数在范围 [1, 100] 内 0 <= Node.val <= 9 题目数据保证列表表示的数字不含前导零
class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { if (l1 == null) return l2; if (l2 == null) return l1; ListNode head = new ListNode(0); //虚拟头节点 ListNode tail = head; int addition = 0; //记录进位 while (l1 != null && l2 != null) { int num = l1.val + l2.val + addition; if (num >= 10) { //两数和大于0,进位为1;否则进位为0 addition = 1; num -= 10; } else addition = 0; tail.next = new ListNode(num); //尾插法 tail = tail.next; l1 = l1.next; l2 = l2.next; } while (l1 != null) { //再处理l1和l2中长的链表 int num = l1.val + addition; if (num >= 10) { addition = 1; num -= 10; } else addition = 0; tail.next = new ListNode(num); tail = tail.next; l1 = l1.next; } while (l2 != null) { int num = l2.val + addition; if (num >= 10) { addition = 1; num -= 10; } else addition = 0; tail.next = new ListNode(num); tail = tail.next; l2 = l2.next; } if (addition == 1) { //注意如果最后一次运算仍然有进位(1+9) //需要再创建一个节点保存进位 tail.next = new ListNode(1); tail = tail.next; } return head.next; } }
删除链表的倒数第 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) { if (head == null) return head; ListNode h = new ListNode(0); //虚拟头节点 h.next = head; ListNode l = h; //l指向目标节点的前一个节点 ListNode r = h; //r是快指针 for (int i = 0; i < n; i++) { r = r.next; } while (r.next != null) { l = l.next; r = r.next; } if (l.next.next == null) l.next = null; else { l.next = l.next.next; } return h.next; } }
合并两个有序链表
LeetCode 21.https://leetcode-cn.com/problems/merge-two-sorted-lists/
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1: 输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4] 示例 2: 输入:l1 = [], l2 = [] 输出:[] 示例 3: 输入:l1 = [], l2 = [0] 输出:[0] 提示: 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列
class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode h = new ListNode(0); //虚拟头节点 ListNode tail = h; while (l1 != null && l2 != null) { if (l1.val < l2.val) { tail.next = l1; //尾插法 tail = tail.next; l1 = l1.next; } else { tail.next = l2; tail = tail.next; l2 = l2.next; } } if (l1 != null) tail.next = l1; //处理l1和l2中长的剩余链表 if (l2 != null) tail.next = l2; return h.next; } }
合并K个升序链表
给你一个链表数组,每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中,返回合并后的链表。 示例 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> q = new PriorityQueue<>((a, b) -> a.val - b.val); for (ListNode node : lists) { //第一次一股脑把所有链表的头节点塞进优先队列 if (node != null) q.add(node); } ListNode h = new ListNode(0); //虚拟头节点 ListNode tail = h; while (!q.isEmpty()) { ListNode node = q.poll(); //每次弹出最小的节点 tail.next = node; //尾插法 tail = tail.next; if (node.next != null) q.add(node.next); //弹出节点的后继节点放入队列 } return h.next; } }
两两交换链表中的节点
给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。 你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。 示例 1: 输入:head = [1,2,3,4] 输出:[2,1,4,3] 示例 2: 输入:head = [] 输出:[] 示例 3: 输入:head = [1] 输出:[1] 提示: 链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100 进阶:你能在不修改链表节点值的情况下解决这个问题吗?(也就是说,仅修改节点本身。)
class Solution { public ListNode swapPairs(ListNode head) { if(head==null || head.next==null) return head; ListNode dummy = new ListNode(0); dummy.next = head; ListNode cur = dummy; while(cur.next != null && cur.next.next != null) { ListNode a = cur.next; ListNode b = a.next; cur.next = b; a.next = b.next; b.next = a; cur = a; } return dummy.next; } }
K 个一组翻转链表
给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。 k 是一个正整数,它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。 进阶: 你可以设计一个只使用常数额外空间的算法来解决此问题吗? 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。 示例 1: 输入:head = [1,2,3,4,5], k = 2 输出:[2,1,4,3,5] 示例 2: 输入:head = [1,2,3,4,5], k = 3 输出:[3,2,1,4,5] 示例 3: 输入:head = [1,2,3,4,5], k = 1 输出:[1,2,3,4,5] 示例 4: 输入:head = [1], k = 1 输出:[1] 提示: 列表中节点的数量在范围 sz 内 1 <= sz <= 5000 0 <= Node.val <= 1000 1 <= k <= sz
class Solution { public ListNode reverseKGroup(ListNode head, int k) { if (head == null || head.next == null) return head; ListNode dummy = new ListNode(-1); //虚拟头节点 dummy.next = head; ListNode cur = dummy; //cur指向反转链表前一个节点 while (cur != null) { reverse(cur, k); int u = k; while (u-- > 0 && cur != null) { cur = cur.next; } } return dummy.next; } public void reverse(ListNode root, int k) { int u = k; ListNode cur = root; while (u-- > 0 && cur != null) cur = cur.next; if (cur == null) return; ListNode a = root.next; ListNode b = a.next; // 当需要翻转 k 个节点时,中间就有 k - 1 个 next 指针需要翻转 while (k-- > 1) { ListNode tmp = b.next; b.next = a; a = b; b = tmp; } root.next.next = b; root.next = a; } }
旋转链表
给你一个链表的头节点 head ,旋转链表,将链表每个节点向右移动 k 个位置。 示例 1: 输入:head = [1,2,3,4,5], k = 2 输出:[4,5,1,2,3] 示例 2: 输入:head = [0,1,2], k = 4 输出:[2,0,1] 提示: 链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109
思路:
注意到k的数据极大,要对k取模,避免不必要的循环。
遍历链表,首尾相连,形成环形链表。
在length - k的位置断开链表,返回下一个节点即可。
class Solution { public ListNode rotateRight(ListNode head, int k) { if (head == null || head.next == null) return head; ListNode dummy = new ListNode(0); dummy.next = head; ListNode a = head; ListNode b = a.next; int length = 1; while (b != null) { a = a.next; b = b.next; length++; } a.next = head; k = k % length; int cnt = length - k; while (cnt-- > 0) dummy = dummy.next; ListNode ans = dummy.next; dummy.next = null; return ans; } }
删除排序链表中的重复元素
存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除链表中所有存在数字重复情况的节点,只保留原始链表中 没有重复出现 的数字。 返回同样按升序排列的结果链表。 示例 1: 输入:head = [1,2,3,3,4,4,5] 输出:[1,2,5] 示例 2: 输入:head = [1,1,1,2,3] 输出:[2,3] 提示: 链表中节点数目在范围 [0, 300] 内 -100 <= Node.val <= 100 题目数据保证链表已经按升序排列
class Solution { public ListNode deleteDuplicates(ListNode head) { ListNode dummy = new ListNode(); ListNode tail = dummy; while (head != null) { // 进入循环时,确保了 head 不会与上一节点相同 if (head.next == null || head.val != head.next.val) { tail.next = head; tail = head; } // 如果 head 与下一节点相同,跳过相同节点 while (head.next != null && head.val == head.next.val) head = head.next; head = head.next; } tail.next = null; return dummy.next; } }
存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除所有重复的元素,使每个元素 只出现一次 。 返回同样按升序排列的结果链表。 示例 1: 输入:head = [1,1,2] 输出:[1,2] 示例 2: 输入:head = [1,1,2,3,3] 输出:[1,2,3] 提示: 链表中节点数目在范围 [0, 300] 内 -100 <= Node.val <= 100 题目数据保证链表已经按升序排列
class Solution { public ListNode deleteDuplicates(ListNode head) { if(head==null||head.next==null) return head; ListNode index = head; while(index.next!=null){ if(index.val==index.next.val){ index.next = index.next.next; }else{ index = index.next; } } return head; } }
相交链表
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。 图示两个链表在节点 c1 开始相交: 题目数据 保证 整个链式结构中不存在环。 注意,函数返回结果后,链表必须 保持其原始结构 。 示例 1: 输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出:Intersected at '8' 解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。 在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。 示例 2: 输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出:Intersected at '2' 解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A 为 [0,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 0 <= m, n <= 3 * 104 1 <= Node.val <= 105 0 <= skipA <= m 0 <= skipB <= n 如果 listA 和 listB 没有交点,intersectVal 为 0 如果 listA 和 listB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]
思路:
- 差值解法:先对两条链表扫描一遍,取得两者长度,然后让长的链表先走「两者的长度差值」,然后再同时走,遇到第一个节点即是答案。
public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if(headA == headB) return headA; ListNode a = headA; ListNode b = headB; int lenA = 0; int lenB = 0; while(a != null) { a = a.next; lenA++; } while(b != null) { b = b.next; lenB++; } if(lenB > lenA) { int l = lenB - lenA; while(l-- > 0) { headB = headB.next; } } else{ int l = lenA - lenB; while(l-- > 0) { headA = headA.next; } } while(headA != null && headB != null) { if(headA == headB) return headA; headA = headA.next; headB = headB.next; } return null; } }
环形链表
给定一个链表,判断链表中是否有环。 如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。 如果链表中存在环,则返回 true 。 否则,返回 false 。 进阶: 你能用 O(1)(即,常量)内存解决此问题吗? 示例 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 或者链表中的一个 有效索引 。
快慢指针法:
public class Solution { public boolean hasCycle(ListNode head) { if(head == null) return false; ListNode fast = head; ListNode slow = head; while(fast != null && fast.next != null) { fast = fast.next.next; slow = slow.next; if(fast == slow) return true; } return false; } }
给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。 说明:不允许修改给定的链表。 进阶: 你是否可以使用 O(1) 空间解决此题? 示例 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 或者链表中的一个有效索引
public class Solution { public ListNode detectCycle(ListNode head) { if(head == null || head.next == null) return null; ListNode fast = head; ListNode slow = head; while(fast != null && fast.next != null) { fast = fast.next.next; slow = slow.next; if(fast == slow) { break; } } if(fast == null || fast.next == null) return null; fast = head; while(fast != slow) { fast = fast.next; slow = slow.next; } return fast; } }
奇偶链表
给定一个单链表,把所有的奇数节点和偶数节点分别排在一起。请注意,这里的奇数节点和偶数节点指的是节点编号的奇偶性,而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1),时间复杂度应为 O(nodes),nodes 为节点总数。 示例 1: 输入: 1->2->3->4->5->NULL 输出: 1->3->5->2->4->NULL 示例 2: 输入: 2->1->3->5->6->4->7->NULL 输出: 2->3->6->7->1->5->4->NULL 说明: 应当保持奇数节点和偶数节点的相对顺序。 链表的第一个节点视为奇数节点,第二个节点视为偶数节点,以此类推。
class Solution { public ListNode oddEvenList(ListNode head) { if(head == null || head.next == null) return head; ListNode evenHead = head.next; ListNode odd = head; ListNode even = evenHead; while(even != null && even.next != null) { odd.next = odd.next.next; odd = even.next; even.next = even.next.next; even = odd.next; } odd.next = evenHead; return head; } }
回文链表
给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false 。 示例 1: 输入:head = [1,2,2,1] 输出:true 示例 2: 输入:head = [1,2] 输出:false 提示: 链表中节点数目在范围[1, 105] 内 0 <= Node.val <= 9 进阶:你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?
思路:后半段链表反转,一个指针指开头,一个指针指中间,双指针扫描
class Solution { public boolean isPalindrome(ListNode head) { if(head.next == null) return true; ListNode dummy = new ListNode(0); dummy.next = head; ListNode l = dummy; ListNode r = dummy; while(r != null && r.next != null) { l = l.next; r = r.next.next; } ListNode a = l.next; ListNode b = a.next; while(b != null) { ListNode tmp = b.next; b.next = a; a = b; b = tmp; } l.next.next = b; l.next = a; ListNode right = l.next; ListNode left = dummy.next; while(right != null) { if(right.val != left.val) return false; left = left.next; right = right.next; } return true; } }
LRU 缓存机制
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类: LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。 void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。 进阶:你是否可以在 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 { Map<Integer,Node> map; int n; Node head; Node tail; class Node{ int k,v; Node l,r; Node(int key, int value){ this.k = key; this.v = value; } } public LRUCache(int capacity) { n = capacity; map = new HashMap<>(); head = new Node(-1, -1); tail = new Node(-1, -1); head.r = tail; tail.l = head; } public int get(int key) { if(map.containsKey(key)) { Node node = map.get(key); refresh(node); return node.v; } return -1; } public void put(int key, int value) { Node node = null; if(map.containsKey(key)) { node = map.get(key); node.v = value; }else { if(n == map.size()) { Node del = tail.l; map.remove(del.k); delete(del); } node = new Node(key, value); map.put(key, node); } refresh(node); } public void refresh(Node node) { delete(node); node.r = head.r; node.l = head; head.r.l = node; head.r = node; } public void delete(Node node) { if(node.l != null) { Node tmp = node.r; node.l.r = node.r; tmp.l = node.l; } } }
相关文章推荐
- 链表相关的算法题大汇总(2) — 数据结构之链表奇思妙想
- 数据结构与算法笔记 lesson8 双向链表
- 数据结构第5章例题 若矩阵Am×n中存在某个元素aij满足:aij是第i行中的最小值且是第j列中的最大值,则称该元素为矩阵A的一个鞍点。试编写一个算法,找出A中的所有鞍点。
- 【数据结构与算法】通俗易懂说链表
- 数据结构与算法——链表
- 数据结构与算法之链表
- 【数据结构与算法】数组和单链表转平衡二叉树
- 数据结构——将两个有序链表并为一个有序链表算法
- 数据结构与算法-链表的基本操作---ShinPans
- 数据结构(3)单循环链表 c++ 模板实现
- 数据结构与算法_链表2_双向链表
- 数据结构与算法(二)合并两个有序链表
- 【学习笔记】数据结构与算法基础学习:链表
- 算法——数据结构基础(数组、队列、栈、链表、散链表)
- 个人数据结构与算法学习总结-队列、链表
- 数据结构与算法学习笔记——链表部分实现(数组形式)
- 链表相关的算法题大汇总 (1)— 数据结构之链表奇思妙想
- 数据结构基础算法-循环链表
- 数据结构与算法——迭代打开url问题(链表)
- 数据结构与算法:链表(如何利用链表实现LRU缓存淘汰算法)