在阅读本篇文章之前，建议读者优先阅读专栏内前面的文章。
目录
前言
本文紧接上篇文章，主要介绍如何使用Java内置的链表类型。
一、链表OJ题续：
第一道题目测试链接如下：链表的回文结构_牛客题霸_牛客网
这道题的思路就是先用快慢指针优先定位中间节点位置，然后反转后半段链表的next的指向，然后进行遍历，读者可以先思考如何自行实现：
java
import java.util.*;
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class PalindromeList {
public boolean chkPalindrome(ListNode head) {
if(head == null) return true;
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
}
ListNode cur = slow.next;
while(cur != null){
ListNode curN = cur.next;
cur.next = slow;
slow = cur;
cur = curN;
}
while(head != slow){
if(head.val != slow.val){
return false;
}
if(head.next == slow){
return true;
}
head = head.next;
slow = slow.next;
}
return true;
}
}
第二道题目测试链接如下：160. 相交链表 - 力扣（LeetCode）
对于这道题，其实我们只要先去计算两个链表的长度差值，然后让长的链表的指针向后移动差值个单位，就可以找到这个相交的点了。
java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode pl = headA;
ListNode ps = headB;
int lenA = 0;
int lenB = 0;
while(pl != null){
lenA++;
pl = pl.next;
}
while(ps != null){
lenB++;
ps = ps.next;
}
pl = headA;
ps = headB;
int len = lenA - lenB;
if(len < 0){
pl = headB;
ps = headA;
len = lenB - lenA;
}
while(len != 0){
pl = pl.next;
len--;
}
while(pl != ps){
pl = pl.next;
ps = ps.next;
}
return pl;
}
}
第三题测试链接如下：141. 环形链表 - 力扣（LeetCode）
这道题的思路很简单，就是使用快慢指针遍历，如果二者能够相遇，就可以证明有环存在。
java
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
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){
slow = slow.next;
fast = fast.next.next;
if(slow == fast){
return true;
}
}
return false;
}
}
这个代码实现相对来说比较简单，我那么我们接下来来思考一下一些拓展的问题。首先我们来思考一下，为什么快慢指针一定会相遇，有没有可能二者会错过，永远都追不上，请证明结论。
我们首先假设链表存在环，若不存在环，快指针会率先走到链表末尾NULL，直接返回无环，不在本次证明范围内，慢指针每次向后移动1步；每次向后移动2步；设链表的非环部分长度为L（，环的长度为C；所有分析基于指针进入环后，在环内做循环移动的特性。当慢指针进入环时，快指针已在环内某位置，当慢指针走了L步时，会到达环的入口节点。此时快指针的移动步数是慢指针的 2倍，即走了2L步；快指针先走完非环部分的 L 步，进入环；剩余的2L - L = L步在环内移动，因此快指针在环内的位置为pos = L % C，即快指针在环内距离入口节点的偏移量为pos，%为取余运算。此时，快慢指针都处于环内，慢指针在环入口，快指针在环内偏移pos的位置，两者的环内相对距离为d，若pos = 0则快指针也在环入口，此时快慢指针直接相遇；若pos > 0则环形结构中，相对距离取最短路径，即d = C - pos，快指针在慢指针后方d步的位置，因为环是封闭的。
快慢指针的相对速度为1步/次，距离持续缩小，慢指针速度为1步/次，快指针速度为2步/次，因此快指针相对于慢指针的速度为1步/次。对于环内的初始相对距离d。每一次循环，快指针都会向慢指针靠近1步，两者的相对距离变为d-1；经过d次循环后，相对距离变为0，即快指针追上慢指针，两者相遇。
而为什么两者不会发生跳过呢，原因如下，若某一时刻，快慢指针的相对距离为1步，慢指针走1步，快指针走2步，则快指针刚好追上慢指针；若某一时刻，快慢指针的相对距离为2步：慢指针走 1步，快指针走2步，则下次循环就会追上；以此类推，由于相对速度是1步/次，快指针每次只会向慢指针靠近1步，不会出现 "跨步跳过" 的情况。也就是说，我们可以得出结论，在链表存在环的前提下，快慢指针的相对速度为1步/次，环内的相对距离会以1步/次的速度持续缩小，最终必然相遇。因此，用快慢指针检测链表环时，只要存在环，就一定能通过指针相遇判定，不会出现永远追不上的情况。
然后我们考虑一下，如果说快指针不是走两步，而是三步、四步甚至更多，是不是还会有与上面相似的结论？
我们在上面的图片中简单讨论了一下情况，接下来我们尝试严密地证明一下。当快指针的步长超过 2步，如3步、4步甚至更多时，不再能保证快慢指针一定相遇，而是可能会出现永远错过、无限循环的情况。这一结论的核心在于快慢指针的相对速度与环的长度的最大公约数 ，决定了两者是否能相遇------只有当相对速度与环长的最大公约数能整除初始相对距离时，才会相遇；否则会陷入循环，永远错过。
假设链表存在环，定义慢指针每次移动1步；快指针每次移动k步；非环部分长度为L，环的长度为C；当慢指针走L步进入环入口时，快指针已走k*L步：先走完L步进入环，剩余(k*L - L) = L*(k-1)步在环内移动，因此快指针在环内的初始位置为 pos = L\*(k-1) % C；快慢指针的初始相对距离为d，环形结构中，相对距离取快指针到慢指针的最短步数，即d = (C - pos) % C；快慢指针的相对速度为v = k - 1：快指针每次比慢指针多走k-1步。
快慢指针相遇的本质是存在正整数t，使得t次移动后，快指针通过相对速度弥补初始相对距离d，且总弥补的步数是环长C的整数倍。我们可以将上述关系转化为线性同余方程：
这个方程的含义是t次移动后，快指针相对慢指针走的步数t*v，减去初始相对距离d，结果是环长C的整数倍即绕环整数圈后追上。根据数论中线性同余方程解的存在性，我们必须要满足相对速度与环长的最大公约数能整除初始相对距离，否则方程会无解使整个过程陷入死循环。此时我们再看看上面这个图，就可以很好的理解了。
二、LinkedList的模拟实现：
LinkedList就是无头双向链表，我们还是创建一个类来实现上篇文章的IList接口。
java
public class MyLinkedList implements IList {
static class ListNode{
public int val;
public ListNode next;
public ListNode prev;
public ListNode(int val){
this.val = val;
}
}
public ListNode head;
public ListNode tail;
@Override
public void addFirst(int data) {
}
@Override
public void addLast(int data) {
}
@Override
public void addIndex(int index, int data) {
}
@Override
public boolean contains(int key) {
return false;
}
@Override
public void remove(int key) {
}
@Override
public void removeAllKey(int key) {
}
@Override
public int size() {
return 0;
}
@Override
public void clear() {
}
@Override
public void display() {
}
}本质来说，这种实现只比我们之前的单链表的形式复杂了一点点，所以读者可以先行尝试，我这里给出我的实现代码：
java
import java.util.List;
public class MyLinkedList implements IList {
static class ListNode{
public int val;
public ListNode next;
public ListNode prev;
public ListNode(int val){
this.val = val;
}
}
public ListNode head;
public ListNode last;
@Override
public void addFirst(int data) {
ListNode node = new ListNode(data);
if(head == null){
head = last = node;
}else{
node.next = head;
head.prev = node;
head = node;
}
}
@Override
public void addLast(int data) {
ListNode node = new ListNode(data);
if(head == null){
head = last = node;
}else{
last.next = node;
node.prev = last;
last = last.next;
}
}
@Override
public void addIndex(int index, int data) {
int len = size();
if(index < 0 || index > len){
return;
}
if(index == 0){
addFirst(data);
return;
}
if(index == len){
addLast(data);
return;
}
ListNode node = new ListNode(data);
ListNode cur = findIndex(index);
node.next = cur;
cur.prev.next = node;
node.prev = cur.prev;
cur.prev = node;
}
private ListNode findIndex(int index){
ListNode cur = head;
while(index != 0){
cur = cur.next;
index--;
}
return cur;
}
@Override
public boolean contains(int key) {
ListNode cur = head;
int count = 0;
while(cur != null){
if(cur.val == key){
return true;
}
cur = cur.next;
}
return false;
}
@Override
public void remove(int key) {
ListNode cur = head;
while(cur.next != null){
if(cur.val == key) {
if (cur == head) {
head = head.next;
if (head != null) {
head.prev = null;
}
} else {
cur.prev.next = cur.next;
if (cur.next == null) {
last = last.prev;
} else {
cur.next.prev = cur.prev;
}
}
return;
}
cur = cur.next;
}
}
@Override
public void removeAllKey(int key) {
ListNode cur = head;
while(cur.next != null){
if(cur.val == key) {
if (cur == head) {
head = head.next;
if (head != null) {
head.prev = null;
}
} else {
cur.prev.next = cur.next;
if (cur.next == null) {
last = last.prev;
} else {
cur.next.prev = cur.prev;
}
}
}
cur = cur.next;
}
}
@Override
public int size() {
ListNode cur = head;
int count = 0;
while(cur != null){
count++;
cur = cur.next;
}
return count;
}
@Override
public void clear() {
ListNode cur = head;
while(cur != null){
ListNode curN = cur.next;
cur.next = null;
cur.prev = null;
cur = curN;
}
head = last = null;
}
@Override
public void display() {
ListNode cur = head;
while(cur != null){
System.out.println(cur.val + " ");
cur = cur.next;
}
System.out.println();
}
}三、LinkedList的使用：
在使用他之前我们先来弄清楚什么是LinkedList，它的官方文档链接如下：
LinkedList (Java Platform SE 8 )
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
在集合框架中，LinkedList也实现了List接口，具体如下：
接下来我们来深入看一下这部分内容，我们首先看下如何去创建一个这种链表：
java
LinkedList<Integer> list = new LinkedList<Integer>();然后我们看下它的源码中的构造方法是什么样的：
java
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}可以看到，它的源码是比较简短的，也很容易理解，这里不再多说。对于LinkedList来说，它的常用方法有以下这些：
| 方法 | 解释 |
|---|---|
| boolean add(E e) | 尾插e |
| void add(int index, E element) | 将e插入到index位置 |
| boolean addAll(Collection<? extends E> c) | 尾插c中的元素 |
| E remove(int index) | 删除index位置元素 |
| boolean remove(Object o) | 删除遇到的第一个o |
| E get(int index) | 获取下标index位置元素 |
| E set(int index, E element) | 将下标index位置元素设置为element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断o是否在线性表中 |
| int indexOf(Object o) | 返回第一个o所在下标 |
| int lastIndexOf(Object o) | 返回最后一个o的下标 |
| List<E> subList(int fromIndex, int toIndex) | 截取部分list |
读者可以自行复制下面的代码去自行观看运行结果：
java
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
System.out.println(list);
// 在起始位置插入0
list.add(0, 0); // add(index, elem): 在index位置插入元素elem
System.out.println(list);
list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
list.removeFirst(); // removeFirst(): 删除第一个元素
list.removeLast(); // removeLast(): 删除最后元素
list.remove(1); // remove(index): 删除index位置的元素
System.out.println(list);
// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
if(!list.contains(1)){
list.add(0, 1);
}
list.add(1);
System.out.println(list);
System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
int elem = list.get(0); // get(index): 获取指定位置元素
list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
List<Integer> copy = list.subList(0, 3);
System.out.println(list);
System.out.println(copy);
list.clear(); // 将list中元素清空
System.out.println(list.size());
}对于它的遍历，和我们之前讲过的一样，它也是有三种方法，这里不再多做赘述：
java
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
}
System.out.println();
}四、ArrayList和LinkedList的区别
对于这两种数据结构类型，我们简单做一下相关的辨析：
总结
本文主要介绍了Java中链表的相关知识，包括链表OJ题的解法实现、LinkedList的模拟实现及其使用方法。文章首先讲解了链表的回文结构、相交链表和环形链表三道OJ题的解题思路与代码实现，重点分析了快慢指针在环形链表中的应用及其数学原理。随后详细展示了如何模拟实现一个无头双向链表（MyLinkedList），包括节点结构定义和各类方法的实现。最后介绍了Java标准库中LinkedList的使用方法，包括常用API和遍历方式，并与ArrayList进行了对比，总结了两者在随机访问、插入删除效率等方面的差异。全文通过代码示例和理论分析相结合的方式，帮助读者深入理解链表的实现原理和应用场景。