系列文章目录
集合及数据结构第六节————链表、单链表的实现和练习
链表、单链表的实现和练习
- ArrayList的缺陷
- 链表的概念及结构
- 单链表的实现
- 链表练习题
一、ArrayList的缺陷
之前已经熟悉了ArrayList的使用，并且进行了简单模拟实现。通过源码知道，ArrayList底层使用数组来存储元素：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// ...
// 默认容量是10
private static final int DEFAULT_CAPACITY = 10;
//...
// 数组：用来存储元素
transient Object[] elementData; // non-private to simplify nested class access
// 有效元素个数
private int size;
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
} //...
}
由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构
二、链表
1.链表的概念及结构
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。它就类似火车，是由一个一个的节点（车厢）组成的
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
-
单向或者双向
-
带头或者不带头
-
循环或者非循环
虽然有这么多的链表的结构，但是我们重点掌握两种:
-
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。
-
无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表
2.单链表的实现（ * * * ）
定义接口
public interface Ilist {
public void addFirst(int data);//头插法
public void addLast(int data);//尾插法
public void addIndex(int index,int data);//任意位置插入,第一个数据节点为0号下标
public boolean contains(int key);//查找是否包含关键字key是否在单链表当中
public void remove(int key);//删除第一次出现关键字为key的节点
public void removeAllKey(int key); //删除所有值为key的节点
public int size();//得到单链表的长度
public void clear() ;
public void display() ;
}
定义链表的内部类
static class ListNode {//将节点定义成内部类
public int value;//数据域
public ListNode next;//节点（引用类型）
public ListNode(int value) {
this.value = value;
//没有初始化next默认为null（因为next是引用数据类型）
}
public ListNode head;//头节点
}
接口的实现
头插法
头插法的时间复杂度为O（1）
- 实例化一个节点
- 改变插入节点的next
- 改变head
- 当链表一个节点都没有时，直接将head指向这个节点
public void addFirst(int data) {//头插法
ListNode newNode = new ListNode(data);//创建一个新的节点
if(this.head != null){//当链表中有其他节点时
newNode.next = this.head;//让新节点的next域指向原来的第一个节点（head所指向的）
this.head = newNode;//让head重新指向新的节点
}else {//当链表中没有其他节点时
this.head = newNode;//直接让head指向新的节点
}
}
尾插法
尾插法的时间复杂度为O(N)
- 实例化一个节点
- 找到最后一个节点
- 改变最后一个节点的next
- 当链表一个节点都没有时，直接将head指向这个节点
public void addLast(int data) {//尾插法
ListNode newNode= new ListNode(data);
if (this.head == null){//当链表中没有其他节点时
this.head = newNode;
}else {//当链表中有其他节点时
//找最后一个节点
ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
while (cur.next != null){
cur = cur.next;//让head指向下一个节点
}
cur.next = newNode;//改变最后一个节点的next，让它指向新的节点
}
}
任意位置插入,第一个数据节点为0号下标
- 检查index输入是否合法
- 让cur走index - 1步（新增一个private修饰的searchPrev方法来找到index位置节点的前一个节点）
- 先让新节点的next域指向下一个节点（cur的next域），然后再让cur的next域指向新节点、
public class AddIndexLocationWrong extends RuntimeException{//自定义异常（输入下标不合法）
public AddIndexLocationWrong(String message){
super(message);
}
}
private ListNode searchPrev(int index){//找到index位置节点的前一个节点
ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
int count = 0;//用来控制循环次数
while (count != index - 1){
cur = cur.next;//让cur指向下一个节点
count++;
}
return cur;
}
public void addIndex(int index, int data) {//任意位置插入,第一个数据节点为0号下标
if(index < 0 || index >size()){//如果输入的index对应节点没有数据，抛出异常
throw new AddIndexLocationWrong("输入的index位置不合法" + index);
}
if (index == 0) {//在开头插入直接调用头插法
addFirst(data);
return;
}
if (index == size()){//在结尾插入，直接调用尾插法
addLast(data);
return;
}
ListNode cur = searchPrev(index);//找到index位置节点的前一个节点
ListNode newNode = new ListNode(data);//创建一个新的节点
newNode.next = cur.next;//让新节点的next域指向下一个节点
cur.next = newNode;//再让cur的next节点指向newNode
}
查找是否包含关键字key是否在单链表当中
public boolean contains(int key) {//查找是否包含关键字key是否在单链表当中
ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
while (cur != null){
if (cur.value == key){
return true;
}
cur = cur.next;
}
return false;
}
删除第一次出现关键字为key的节点
- 找到第一次出现关键字为key的节点的前一个节点（新增一个private修饰的 findPrev 方法来找到第一次出现关键字为key的节点的前一个节点）
- 判断返回值是否为空
- 删除第一次出现关键字为key的节点
private ListNode findPrev(int key){//找到第一次出现关键字为key的节点的前一个节点
ListNode cur = this.head;
while (cur.next != null){//因为已经进行了最后一个节点数据的比较
if(cur.next.value ==key) { // 所以不需要让cur遍历完整个链表的节点
return cur; //（如果这样后面就会让值为null的cur的数据域与key比较就会报空指针异常的错误)
}
cur = cur.next;
}
return null;
}
public void remove(int key) {//删除第一次出现关键字为key的节点
//一个节点都没有，无法删除
if(this.head == null) {
return;
}
if(this.head.value ==key){//当关键字为key的节点是头节点时，删除头节点
this.head = this.head.next;
return;
}
ListNode cur = findPrev(key);找到第一次出现关键字为key的节点的前一个节点
if(cur == null){
System.out.println("没有你要删除的数字");
return;
}
ListNode del = cur.next;//要删除的节点
cur.next = del.next;//直接跳过了要删除的节点指向了它的下一个节点
}
删除所有值为key的节点
public void removeAllKey(int key) {//删除所有值为key的节点
if (this.head == null){//头节点为null时，不能删除
return;
}
ListNode prev = this.head;//指向值为key的节点的前一个节点
ListNode cur = this.head.next;//指向值为key的节点
while (cur != null){
if (cur.value == key){//当cur的数据域的值域key相等时（prev的指向不变，cur的指向改变）
prev.next = cur.next;//prev的next域直接跳过cur指向的节点指向它的下一个节点
cur = cur.next;//cur指向cur的下一个节点
}else {//当cur的数据域的数值域与key不相等时（prev和cur的指向都改变）
prev = cur;//prev指向cur（prev向后移动一个节点）
cur = cur.next;//cur指向cur的next域指向的节点（cur向后移动一个节点）
}
}
if (this.head.value ==key){//当头节点的数据域的值也为key时
this.head = this.head.next;//头节点指向下一个节点（该节点不在被引用就会被回收）
return;
}
}
得到单链表的长度
public int size() {//得到单链表的长度
ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
int count = 0;//用来计数
while (cur != null){
count++;
cur = cur.next;
}
return count ;
}
清空
public void clear() {//清空
ListNode cur = this.head;
while (cur != null){
ListNode curNext = cur.next;//在cur被置空前指向cur的下一个节点
cur.next = null; // 以便将链表全部置空
cur = curNext;
}
head = null;//将头节点置空
}
打印链表的数据
要创建一个临时节点来替head节点完成工作，从而避免head = null的情况出现
public void display() {//打印链表的数据
ListNode cur = this.head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
while (cur != null){//打印的停止条件
System.out.print(cur.value + " ");
cur = cur.next;//让head指向下一个节点
}
System.out.println();
}
结论
- 在插入一个节点的时候，一定要先绑定后面这个节点
3.链表练习题（ * * ）
删除链表中等于给定值 val 的所有节点
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
class Solution {
public ListNode removeElements(ListNode head, int val) {
if (head == null){//头节点为null时，不能删除
return null;
}
ListNode prev = head;//指向值为val的节点的前一个节点
ListNode cur = head.next;//指向值为val的节点
while (cur != null){
if (cur.val == val){//当cur的数据域的值域val相等时（prev的指向不变，cur的指向改变）
prev.next = cur.next;//prev的next域直接跳过cur指向的节点指向它的下一个节点
cur = cur.next;//cur指向cur的下一个节点
}else {//当cur的数据域的数值域与val不相等时（prev和cur的指向都改变）
prev = cur;//prev指向cur（prev向后移动一个节点）
cur = cur.next;//cur指向cur的next域指向的节点（cur向后移动一个节点）val
}
}
if (head.val == val){//当头节点的数据域的值也为val时
head = head.next;//头节点指向下一个节点（该节点不在被引用就会被回收）
}
return head;
}
}
反转一个单链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
- 先新建一个临时节点cur用来存放头节点next域的数据
- 将头节点置空
- 从头节点后面的节点开始运用头插法插入链表
class Solution {
public ListNode reverseList(ListNode head) {
if (head == null) {//头节点为null时，不能反转
return null;
}
if (head.next == null) {//只有一个节点，不需要反转
return head;
}
ListNode cur = head.next;//先新建一个临时节点cur用来存放头节点next域的数据
head.next = null;// 将头节点置空
while (cur != null) {
ListNode aftCur = cur.next;//新建一个临时节点aftCur用来存放cur节点next域的数据
cur.next = head;//让cur节点的next域指向原来的第一个节点（head所指向的）
head = cur;//让head重新指向cur节点
cur = aftCur;
}
return head;
}
}
链表的中间结点
给你单链表的头结点 head ，请你找出并返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
示例 1：
输入：head = [1,2,3,4,5]
输出：[3,4,5]
解释：链表只有一个中间结点，值为 3 。
示例 2：
输入：head = [1,2,3,4,5,6]
输出：[4,5,6]
解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。
方法一
- 先求整个链表的长度
- 再根据长度的/2找到这个中间节点
class Solution {
public ListNode middleNode(ListNode head) {
ListNode cur = head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
int len = 0;//用来计算链表长度
while (cur != null) {
len++;
cur = cur.next;
}
if(len == 0){//链表中没有节点
return null;
}
if (len == 1){//链表中只有一个节点
return head;
}
ListNode cur1 = head;
for (int i = 0; i < len / 2; i++) {
cur1 = cur1.next;
}
return cur1;
}
}
方法二（快慢指针）
创建两个临时节点一个节点一次移动两个节点，另一个一次移动一个节点当快的那个指向null时，慢的那个节点所指向的就是目标节点 （当fast == null 或者 fast . next == null时结束循环）
public ListNode middleNode(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){//当fast和fast.next都不为null时才会进入循环
fast =fast.next.next;//fast一次走两步 //判断条件顺序不能交换，
slow = slow.next;//slow一次走一步 // 因为如果链表为空时判断fast.next会直接报空指针异常的错误
}
return slow;
}
}
输出链表中倒数第k个结点
方法一
走len - k步后输出
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
//1. 先求链表长度
ListNode cur = head;//创建一个临时节点来替head节点完成工作
//从而避免head = null的情况出现
int len = 0;//用来计算链表长度
while (cur != null) {
len++;
cur = cur.next;
}
if (k < 0 || k > len) {//如果输入的k对应节点不合法，返回null
return null;
}
if(len == 0){//链表中没有节点
return null;
}
if (len == 1){//链表中只有一个节点
return head;
}
ListNode cur1 = head;
for (int i = 0; i < len - k; i++) {
cur1 = cur1.next;
}
return cur1;
}
}
方法二（快慢指针）
要找倒数第k个节点，fast 与 slow 之间只需要差k - 1步（fast先走k-1步后再一起走，当fast.next == null 时停止。这时slow就是所要的节点）
- 判断k的合法性（主要是判断k非常大的时候）
- fast先走k-1步
- fast和slow同时走
- fast到最后slow的位置就是倒数第k个节点
public ListNode FindKthToTail(ListNode head,int k) {
if (k < 0 || head == null) {//如果输入的k小于0，返回null
return null;
}
ListNode fast = head;
ListNode slow = head;
int count = 0;//用来记录fast走的次数
while ( k -1 != count){//当fast走完k - 1 步后（k - 1 == count）
fast = fast.next; //结束循环
if(fast == null){//当k非常大（导致fast走的次数超过链表长度）时，返回null
return null;
}
count++;
}
while (fast.next != null){//当fast走到最后一个节点时，结束循环
fast = fast.next;//fast和slow同时移动一步
slow = slow.next;
}
return slow;
}
合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
class Solution {
public ListNode mergeTwoLists(ListNode head1, ListNode head2) {
ListNode newH = new ListNode(-1);//创建一个虚拟节点（不存放真实的数据）
ListNode tempH = newH;//创建一个tempH节点，再让移动后的head1与head2进行比较。谁小就把tempH的next域指向改为谁
while (head1 != null && head2 !=null){
if (head1.val < head2.val){//head1比head2小
tempH.next = head1;//head1比head2小,把tempH的next域指向改为head1
head1 = head1.next;//head1向后移动一个节点
}else {//head2比head1小
tempH.next = head2;//head2比head1小,把tempH的next域指向改为head2
head2 = head2.next;//head2向后移动一个节点
}
tempH = tempH.next;
}
if (head1 != null){//head1剩下的节点都比head2大
tempH.next = head1;
}
if (head2 != null){//head2剩下的节点都比head1大
tempH.next = head2;
}
return newH.next;
}
}
链表分割（ * * * ）
现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
- 遍历链表找到小于x的节点和大于等于x的节点
- 用尾插法把他们放在一起
- 将小于x的最后一个节点与大于等于x的第一节点重新链接起来，并返回小于x的第一个节点的next域
4. 第一段为空，说明链表里的所有值都大于等于x,会产生空指针异常
5. 第二段有数据时，ae指向的节点的next域可能不为null导致程序死循环。
public class Partition {
public ListNode partition(ListNode pHead, int x) {
if (pHead == null) { //当链表为空时，不能分割。返回null
return null;
}
ListNode bs = null;//表示小于x的节点的头节点
ListNode be = null;//表示小于x的节点的尾节点
ListNode as = null;//表示大于等于x的节点的头节点
ListNode ae = null;//表示大于等于x的节点的尾节点
ListNode cur = pHead;//创建一个临时节点来替pHead节点完成工作
//从而避免head = null的情况出现
while (cur != null) {
if (cur.val < x) { //节点小于x
if (bs == null) { //插入第一个节点
bs = cur;
be = cur;
} else {//尾插法插入
be.next = cur;
be = be.next;//be永远指向最后一个节点
}
} else {//节点大于等于x
if (as == null) {//插入第一个节点
as = cur;
ae = cur;
} else {//尾插法插入
ae.next = cur;
ae = ae.next;
}
}
cur = cur.next;//无论如何都会执行这条语句来先后移动一个节点
}
//开始链接小于x的最后一个节点与大于等于x的第一节点
if (bs == null) { //第一段为空，说明链表里的所有值都大于等于x,直接返回第二段
return as;
}
//第一段有数据
be.next = as;
if (as != null) { //第二段有数据时，ae指向的节点的next域可能不为null导致程序死循环。
ae.next = null;
}
return bs;
}
}
链表的回文结构（ * * * ）
描述
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900
测试样例：
1->2->2->1
返回：true
-
找到中间位置
-
从中间大的节点以后开始翻转
- 进行比较,直到相遇。
链表是奇数的情况：
链表是偶数的情况：
public class PalindromeList {
public boolean chkPalindrome(ListNode head) {
if (head == null || head.next == null){//当链表没有节点或者只有一个节点时，返回true
return true;
}
ListNode fast = head;
ListNode slow = head;
//1. 找到中间位置
while (fast != null && fast.next != null){//当fast和fast.next都不为null时才会进入循环
fast = fast.next.next;//fast一次走两步 //判断条件顺序不能交换，
slow = slow.next;//slow一次走一步 // 因为如果链表为空时判断fast.next会直接报空指针异常的错误
}
//2.从中间大的节点以后开始翻转
ListNode cur = slow.next;//创建一个临时节点cur，让cur指向slow的下一个节点
while (cur != null) {
ListNode curNext = cur.next;//创建curNext节点用来保存改变前的cur.next
cur.next = slow;//让slow后面的第一个节点的next域指向slow
slow = cur;//向后移动一个节点，进行下一个节点的反转
cur = curNext;//cur向后移动一个节点
}
//3.进行比较,直到相遇
while (head != slow){
if (head.val != slow.val){//判断head的的val是否与slow的相等，如果不相等直接返回false
return false;
}
if (head.next == slow){//当链表为偶数时，如果head.next与slow相等返回true
return true;
}
head = head.next;//head向后移动一个节点
slow = slow.next;//slow向后移动一个节点
}
return true;
}
}
相交链表
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 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 。
- 分别求两个链表的长度
- 求两个链表长度差的绝对值len
- 让长的链表先走len步
- 同时走
- 相遇的节点就是相遇点
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode pl= headA;//pl表示长的链表，先默认A比B长
ListNode ps = headB;//ps表示短的链表，先默认B短
int len1 = 0;
int len2 = 0;
//1. 分别求两个链表的长度
while (pl != null){
len1++;
pl = pl.next;
}
while (ps != null){
len2++;
ps = ps.next;
}
//因为pl在上面进行了链表长度的计算，pl会指向null
//所有要对pl和ps重新赋值
pl = headA;
ps = headB;
//2.求两个链表长度差的绝对值len
int len = len1 - len2;
if(len < 0){//如果B更长，更改一下pl和ps的指向
pl = headB;//pl一定指向最长的链表
ps = headA;//ps一定指向最短的链表
len = len2 - len1;//len一定为正数
}
//3. 让长的链表先走len步
while (len != 0){//
pl = pl.next;
len--;
}
//4. 同时走
while (pl != ps){
pl = pl.next;
ps = ps.next;
}
if (ps == null){//如果ps = null 说明pl与ps长度一样且没有相交的节点，
return null; //此时返回null
}
//5. 相遇的节点就是相遇点
return pl;
}
}
环形链表
给你一个链表的头节点 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
解释：链表中没有环。
【思路】
快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表起始位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。（如果没有环最快的一定是先为空）
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){//当fast和fast.next都不为null时才会进入循环
fast = fast.next.next;//fast一次走两步 //判断条件顺序不能交换，
slow = slow.next;//slow一次走一步 // 因为如果链表为空时判断fast.next会直接报空指针异常的错误
if(fast == slow){//当fast与slow相遇的时候说明有环
return true;
}
}
return false;
}
}
【思考】
-
为什么快指针每次走两步，慢指针走一步可以？
假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在慢指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。 -
快指针一次走3步，走4步，…n步行吗？
返回链表开始入环的第一个节点
给定一个链表的头节点 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
解释：链表中没有环。
【思路】
让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。
- fast转了一圈半
fast的速度时slow的二倍
- fast转了很多圈才相遇
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){//当fast和fast.next都不为null时才会进入循环
fast = fast.next.next;//fast一次走两步 //判断条件顺序不能交换，
slow = slow.next;//slow一次走一步 // 因为如果链表为空时判断fast.next会直接报空指针异常的错误
if(fast == slow){//当fast与slow相遇的时候说明有环,结束循环
break;
}
}
if (fast == null || fast.next ==null){//没有环
return null;
}
slow = head;//slow从开头走
while (slow != fast){//fast从相遇点开始走
slow = slow.next;//slow一次走一步
fast = fast.next;//fast一次走一步
}
return fast;//无论fast是正好转了1.5圈还是转了很多圈，slow和fast相遇的节点就是入环点
}
}
1011
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
