Leetcode链表刷题总结（Java版）

链表

1、移除链表元素（考虑全情况）

问题需求：根据给定的val值，移除链表中值是这个val的节点

203. 移除链表元素 - 力扣（LeetCode）

这里有一个问题就是，如果需要被移除的节点不是中间的某个节点，而是头节点。就没法借助前一个节点了，而是直接将

head = head.next

所以有两种思路，要么是分类处理；要么是在原本的head节点前面增加一个虚拟头节点，这样头节点也有个前面的节点了

还有需要注意的是，这里的代码，不应该用if，因为我们是一直移除的一个过程，所以应该用while

思路一：

public ListNode removeElements(ListNode head, int val) {while(head != null && head.val == val)  //之所以不用if，是因为可能从头结点开始有连续的等于val的节点head = head.next;ListNode cur = head;		//删除非头节点情况while(cur != null && cur.next != null){if(cur.next.val = val)cur.next = cur.next.next;elsecur = cur.next;}return head;
}

思路二：

ListNode dummyHead = new ListNode(0); // 设置⼀个虚拟头结点
dummyHead.next = head; 			// 将虚拟头结点指向head，这样⽅⾯后⾯做删除操作
ListNode cur = dummyHead;
while(cur.next != null){...
}
return dummyHead.next;

2、设计链表【个人觉得想熟悉链表时可以练这个】

707. 设计链表 - 力扣（LeetCode）

在这里插入图片描述

就是实现关于链表的各个操作，为了方便，还是用上了虚拟头节点

初始化中的0就是虚拟头节点了

3、反转链表（双指针）

206. 反转链表 - 力扣（LeetCode）

双指针法

遍历链表，按照头插法，将旧链表的一个个节点放到新链表的头节点，最后反转成功

public ListNode reverseList(ListNode head) {ListNode cur = head;ListNode first = null;while(cur!=null){ListNode tmp = cur.next;    // 保存⼀下 cur的下⼀个节点，因为接下来要改变cur->nextcur.next = first;           //头部插入//更新双指针first = cur;cur = tmp;}return first;
}

4、两两交换链表中的节点（借助虚拟头节点）

24. 两两交换链表中的节点 - 力扣（LeetCode）

在这里插入图片描述

需要借助虚拟头节点，这样操作会简单一点

每次需要一个指针cur指向需要被交换的两个节点，的前一个节点

顺序就是，虚拟头节点先指向2，然后让2指向1，最后1指向3。而这里的“1”和“3”是需要两个临时节点记录一下

public ListNode swapPairs(ListNode head) {ListNode  dummyHead = new ListNode(0);dummyHead.next = head;ListNode cur = dummyHead;while(cur.next != null && cur.next.next != null){ListNode tmp = cur.next;ListNode tmp1 = cur.next.next.next;cur.next = cur.next.next;cur.next.next = tmp;cur.next.next.next = tmp1;cur = tmp;                  // 或者cur = cur.next.next;  cur移动两位，准备下⼀轮交换}return dummyHead.next;
}

5、删除链表倒数第N个节点（快慢指针）

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

由于需要删除的是倒数第N个，所以可以用快慢指针
双指针的经典应⽤，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了
这里需要注意的就是，需要虚拟头节点，考虑到了如果链表只有一个元素，或者只有两个元素的情况

这种时候，用到虚拟头节点，就很好的可以处理

另外，最后返回的时候，不要返回head，而是返回dummyhead.next，因为如果只有一个节点的情况，删除后，就没有head，就知识null了，所以不能返回head

public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummyhead = new ListNode(0);dummyhead.next = head;ListNode fast = dummyhead;ListNode slow = dummyhead;for(int i = 0; i < n; i++)fast = fast.next;fast = fast.next;			 // fast再提前⾛⼀步，因为需要让slow指向删除节点的上⼀个节点while(fast != null){      slow = slow.next;fast = fast.next;}slow.next = slow.next.next;return dummyhead.next;      //不能返回head，只能是dummyhead.next
}

6、链表相交：寻找两个链表(无环结构)重合结点

面试题 02.07. 链表相交 - 力扣（LeetCode）

其实这个链表问题主要需要总结的就是那些经验及方法，而对于两个无环结构的链表，就是常规方法

先是求出连两个链表的长度length1，length2，然后就是需要判断这两个链表的尾结点是不是一样的

如果连尾结点都不一样，就说明两个链表连一个结点都没有重合，所以两个链表绝对不会重合

如果尾结点一样的话，需要将两个链表的长度互减

然后这个数num的绝对值就是这两个链表长度的差值，**让长链表提前走num步，然后两个链表再同时走，**直到遇见了相同的交点处停下来返回此结点，具体代码如下：

public static Node noLoop(Node head1, Node head2) {if (head1 == null || head2 == null) {	return null;   }Node cur1 = head1;Node cur2 = head2;int n = 0;                      //这里为了简化以及节省空间，就设置了一个变量n,通过下面的两个while循环，一个自加，一个自减，最后求他的绝对值，就是两个链表的长度差值while (cur1.next != null) {n++;cur1 = cur1.next;}while (cur2.next != null) {n--;cur2 = cur2.next;}if (cur1 != cur2) {			   //如果最后一个结点都不一样，那么两个链表绝对不可能有交合的地方了return null;              }cur1 = n > 0 ? head1 : head2;			//谁长，谁的头变成cur1cur2 = cur1 == head1 ? head2 : head1;	 //谁短，谁的头变成cur2n = Math.abs(n);while (n != 0) {			  //先让长链表走了n步n--;cur1 = cur1.next;}while (cur1 != cur2) {		  //开始寻找相交结点cur1 = cur1.next;cur2 = cur2.next;}return cur1;
}

7、环形链表

142. 环形链表 II - 力扣（LeetCode）

划分为两个问题：

判断有环无环
如果有环的话，找到环的起始节点

1）判断有环无环

判断链表是否有环，可以借助哈希表set，也可以用快慢指针，

**1）哈希表set：**将所有节点放进set中，每放进去一个节点都查查这个节点是不是在集合中，第一次查到这个节点在集合中的时候，就说明这个节点就是环的起点

2）快慢指针： 只要最后不会指向空【如果快指针指向空了，就说明没有环】，并且快慢指针重合，就说明该链表又环。判断有环之后，就要开始找环的起始点，看下面的描述

//哈希表set
public static boolean hasCycle(Node head){HashSet<Node> set = new HashSet<Node>();set.add(head);Node cur = head.next;while(true){if(set.contains(cur))return true;else{set.add(cur);cur=cur.next;if(cur==null)return false;}}
}

//快慢指针
public static boolean ifCycle(Node head){Node slow = head;Node fast = head.next;while(fast != slow){if(fast == null)return false;slow = slow.next;fast = fast.next.next;}return true;
}

2）找到环的起始节点

这里一开始还是借助快慢指针，先是判断有无环结构：

如果有环的话，也就是说快慢指针在环上的某一个结点上重合了。（这是第一个while循环）
此后就到了本方法的骚气处了【这是通过公式推导出来的规律！！记住这个结论！！！】
- 将快指针转移到头结点的位置，慢节点还是在原来环上面两个指针相遇的位置
- 快慢指针的的移动步长都变为一
- 此时他们再相遇重合的那个位置就是环结点的起始处了（这是第二个while循环），直接上代码：

public ListNode detectCycle(ListNode head) {ListNode fast = head;ListNode slow = head;while(fast != null && fast.next != null){fast = fast.next.next;slow = slow.next;if(slow == fast)break;}if(fast == null || fast.next == null)  //跳出上面循环时有两种可能，一是没有环，另外就是slow == fast。所以需要判断如果										//无环的话，直接返回nullreturn null;fast = head;while(fast != slow){fast = fast.next;slow = slow.next;}return fast;
}

8、判断回文结构

借助栈

public static boolean isPalindrome1(Node head) {Stack<Node> s = new Stack<Node>();Node cur = head;while(cur != null){s.push(cur);cur = cur.next;}cur = head;while(head != null){if(head.val != s.pop().val)return false;head = head.next;}return true; 
}