承接上文 Java-数据结构-链表<一>
一. 链表简单介绍
见 Java-数据结构-链表<一>
二. 链表的代码实现
见 Java-数据结构-链表<一>
三. leetcode&牛客实例
1-6 见 Java-数据结构-链表<一>
7. leetcode160 相交链表
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null 。
图示两个链表在节点 c1 开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
自定义评测:
评测系统 的输入如下(你设计的程序 不适用 此输入):
intersectVal - 相交的起始节点的值。如果不存在相交节点,这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中(从头节点开始)跳到交叉节点的节点数
skipB - 在 listB 中(从头节点开始)跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构,并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点,那么你的解决方案将被 视作正确答案 。
输入: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 个节点。
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode a = headA;
ListNode b = headB;
while(a != b){
a = (a != null ? a.next : headB);
b = (b != null ? b.next : headA);
}
return a;
}
}
【1】:
走到尽头见不到你,于是走过你来时的路,等到相遇时才发现,你也走过我来时的路。【2】
8. leetcode142 环形链表II
给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。不允许修改 链表。
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head == null || head.next == null) return null;
ListNode fast = head;
ListNode slow = head;
while(true){
if(fast == null || fast.next == null) return null;
slow = slow.next;
fast = fast.next.next;
if(slow == fast) break;
}
fast = head;
while(fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
}
本题小结:(1)这个和环形链表I很相似,但是要判断出具体环形的入口
(2)在while(true)种设置关于fast遇到不是环形链表的情况提前退出
9. leetcode203 移除链表元素
给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
class Solution {
public ListNode removeElements(ListNode head, int val) {
if(head == null) return null;
ListNode dummyhead = new ListNode(0);
dummyhead.next = head;
ListNode tail = dummyhead;
ListNode pre = head;
while(pre != null){
if(pre.val == val){
tail.next = pre.next;
pre = tail.next;
}
else{
pre = pre.next;
tail = tail.next;
}
}
return dummyhead.next;
}
}
本题小结:(1)对于首,采用dummyhead是不错的选择
(2)对于找到要删除的值,在tail连接好后,pre向前移就可以,因为此时的pre没有被比较过
10. leetcode876 链表的中间节点
给定一个头结点为 head 的非空单链表,返回链表的中间结点。如果有两个中间结点,则返回第二个中间结点。
输入:[1,2,3,4,5]
输出:此列表中的结点 3 (序列化形式:[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意,我们返回了一个 ListNode 类型的对象 ans,这样:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
class Solution {
public ListNode middleNode(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
}
return slow;
}
}
11. leetcode 面试题 02.01. 移除重复节点
编写代码,移除未排序链表中的重复节点。保留最开始出现的节点。
输入:[1, 2, 3, 3, 2, 1]
输出:[1, 2, 3]
class Solution {
public ListNode removeDuplicateNodes(ListNode head) {
if(head == null || head.next == null) return head;
ListNode tail = head;
ListNode pre = head.next;
HashSet<Integer> set = new HashSet<>();
set.add(head.val);
while(pre != null){
if(set.contains(pre.val)){
pre = pre.next;
tail.next = pre;
}
else{
set.add(pre.val);
pre = pre.next;
tail = tail.next;
}
}
return head;
}
}
建立HashSet明显是好做得题目,没有缓冲区怎么办?
也可以使用双重暴力循环来做,花费时间的选项
class Solution {
public ListNode removeDuplicateNodes(ListNode head) {
if(head == null || head.next == null) return head;
ListNode cur = head;
while(cur != null){
ListNode temp = cur;
while(temp.next != null){
if(cur.val == temp.next.val){
temp.next = temp.next.next;
}
else{
temp = temp.next;
}
}
cur = cur.next;
}
return head;
}
}
11. leetcode 剑指 Offer 22. 链表中倒数第k个节点
输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
Deque<ListNode> list = new ArrayDeque<>();
ListNode cur = head;
while(cur != null){
list.push(cur);
cur = cur.next;
}
while(k > 1){
list.pop();
k--;
}
return list.pop();
}
}
12. leetcode 61 旋转链表
给你一个链表的头节点 head ,旋转链表,将链表每个节点向右移动 k 个位置。
输入:head = [1,2,3,4,5], k = 2
输出:[4,5,1,2,3]
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if(head == null || head.next == null) return head;
int sum = 1;
ListNode pre = head;
while(pre.next != null){
sum++;
pre = pre.next;
}
System.out.println(sum);
int diff = k % sum;
System.out.println(diff);
if(diff == 0) return head;
ListNode cur = head;
for(int i = 1; i < sum - diff; i++){
cur = cur.next;
}
ListNode temp = cur.next;
cur.next = null;
pre.next = head;
return temp;
}
}
本题小结:(1)可以通过取余节省时间(数据量小没用)
(2)剩下需要移动的位置就是sum - diff-1了,注意起始值
13. leetcode 19 删除链表的倒数第N个节点
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
双指针,有一个要先走
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if(head == null || n < 1){
return head;
}
ListNode prehead = new ListNode(0);
prehead.next = head;
ListNode fast = prehead;
ListNode slow = prehead;
while(n >= 0){
fast = fast.next;
n--;
}
while(fast != null){
fast = fast.next;
slow = slow.next;
}
if(slow == prehead){
return head.next;
}
slow.next = slow.next.next;
return prehead.next;
}
}
栈,装满倒序遍历
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if(head == null) return head;
ListNode dummyhead = new ListNode(0);
dummyhead.next = head;
ListNode cur = dummyhead;
Deque<ListNode> list = new ArrayDeque<>();
while(cur != null){
list.push(cur);
cur = cur.next;
}
while(n > 1){
list.pop();
n--;
}
ListNode pre = list.pop();
ListNode tail = list.pop();
tail.next = pre.next;
return dummyhead.next;
}
}
参考自
【1】leetcode 房建斌学算法 图解相交链表
【2】leetcode sylin