备战Java后端【Day3】
数据结构1-1
链表3
单链表的基本操作：
- 合并两个有序链表
- 合并k个有序链表
- 寻找单链表的中点
- 寻找单链表中的第k个节点
- 判断单链表是否包含环并找出环起点
- 判断两个单链表是否相交并找出交点
学习目标
- 复习Day1和Day2内容
- 判断单链表是否包含环并找出环起点
- 判断两个单链表是否相交并找出交点
学习内容
单链表操作
- 10. 返回链表的头节点： 在单链表中，直接返回第一个节点即可。
public Node<E> head() {
return first;
}
- 11. 返回链表的尾节点： 在单链表中，首先要判断链表是否为空。若链表为空，那么返回的就是空链表；若不为空，则遍历链表的每个节点，直到next域为空的节点，这个节点就是链表的尾节点。
public Node<E> tail() {
if (first == null) {
return first;
}
else {
Node<E> temp = first;
while (temp.next != null) {
temp = temp.next;
}
return temp;
}
}
***
- 12. 删除指定值的一个节点： 首先要查找链表中是否有这一个值，如果链表长度为0,或者aimValue为null，直接返回false；如果在头节点，则直接移动头节点到下一个节点即可。
public boolean removeOneNode(E aimValue) {
if (first == null || aimValue == null) {
return false;
}
if (first.item.equals(aimValue)) {
first = first.next;
return true;
}
else {
Node<E> temp = first;
while (temp.next != null) {
if (temp.next.item.equals(aimValue)) {
temp.next = temp.next.next;
return true;
}
temp = temp.next;
}
}
return false;
}
- 13. 删除指定值所有节点，返回删除的个数： 遍历链表，查找到这个值的节点都删除，然后计数变量count加1，直到节点的next域为空。
public int removeAllNode(E aimValue) {
if (first == null || aimValue == null) {
return 0;
}
// 循环删除头结点，直到头结点不为目标值
int count = 0;
while (first != null && first.item.equals(aimValue)) {
first = first.next;
count++;
}
if (first != null) {
Node<E> temp = first;
while (temp.next != null) {
if (temp.next.item.equals(aimValue)) {
temp.next = temp.next.next;
count++;
}
else {
temp = temp.next;
}
}
}
return count;
}
- 14. 在一个排序链表中，删除重复节点： 暴力破解法或者双指针法。双指针法利用了排序的性质，由于链表已经排序，如果有重复的节点，那么重复的节点一定是排列在一起的。
- 假设定义指针x为nodeX，指针y为nodeY
- 如果nodeX == nodeY，则另nodeY = nodeY.next
- 如果nodeX != nodeY, 则另nodeX.next = NodeY,删除nodeX->nodeY之间的节点，并另nodex = nodeX.next，nodeY = nodeY.next
public void removeOrderListDupNode() {
// 首先确保头结点和aimValue不是null
if (first == null) {
throw new IllegalArgumentException("目标值不可为null");
}
Node<E> nodeX = first;
Node<E> nodeY = first.next;
while (nodeY != null) {
if (nodeX.item.equals(nodeY.item)) {
nodeY = nodeY.next;
// 如果nodeY == null，则表示循环要结束了
// 如果不另nodeX.next = null,可以会导致没有正确删除节点
// 例如：如果链表是 1,2,2,2,2
// 当nodeX = 2，nodeY = null时，循环直接跳出了，并没有删除节点。
if (nodeY == null) {
nodeX.next = null;
}
}
else {
nodeX.next = nodeY;
nodeX = nodeX.next;
nodeY = nodeY.next;
}
}
}
- 15. 查找指定值节点是否存在： 直接遍历查找即可，但是要考虑链表为空的情况。
public boolean isExist(E aimValue) {
Node<E> temp = first;
while (temp != null) {
if (temp.item.equals(aimValue)) {
return true;
}
temp = temp.next;
}
return false;
}
- 16. 查找指定节点并计数： 直接遍历查找一遍，每找到一个，计数变量加1，直到节点的next域为空。
public int countNode(E aimValue) {
int count = 0;
if (aimValue == null) {
return 0;
}
Node<E> temp = first;
while (temp != null) {
if (temp.item.equals(aimValue)) {
count++;
}
temp = temp.next;
}
return count;
}
学习时间
2022年5月26日
- 下午2点-下午5点
学习产出
- 本文档链表基础知识和基础操作
- 力扣141题，环形链表
- 力扣142题，环形链表Ⅱ
- 力扣160题，相交链表
今日刷题
141.环形链表
- 使用双指针技巧中的快慢指针，每当慢指针 slow 前进一步，快指针 fast 就前进两步。如果 fast 最终遇到空指针，说明链表中没有环；如果 fast 最终和 slow 相遇，那肯定是 fast 超过了 slow 一圈，说明链表中含有环。
public class Solution {
public boolean hasCycle(ListNode head) {
// 快慢指针初始化指向 head
ListNode slow = head, fast = head;
// 快指针走到末尾时停止
while (fast != null && fast.next != null) {
// 慢指针走一步，快指针走两步
slow = slow.next;
fast = fast.next.next;
// 快慢指针相遇，说明含有环
if (slow == fast) {
return true;
}
}
// 不包含环
return false;
}
}
142.环形链表Ⅱ
- 基于 141. 环形链表 的解法，直观地来说就是当快慢指针相遇时，让其中任一个指针指向头节点，然后让它俩以相同速度前进，再次相遇时所在的节点位置就是环开始的位置。我们假设快慢指针相遇时，慢指针 slow 走了 k 步，那么快指针 fast 一定走了 2k 步：
- fast一定比slow多走了 k 步，这多走的 k 步其实就是 fast 指针在环里转圈圈，所以 k 的值就是环长度的「整数倍」。
- 假设相遇点距环的起点的距离为 m，那么结合上图的 slow 指针，环的起点距头结点 head 的距离为 k - m，也就是说如果从 head 前进 k - m 步就能到达环起点。巧的是，如果从相遇点继续前进 k - m 步，也恰好到达环起点：
- 所以，只要我们把快慢指针中的任何一个重新指向head，然后两个指针同速前进，k-m步后一定会相遇，相遇之处便是环的起点。
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast, slow;
fast = slow = head;
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if (fast == slow) break;
}
// 上面的代码类似 hasCycle 函数
if (fast == null || fast.next == null) {
// fast 遇到空指针说明没有环
return null;
}
// 重新指向头结点
slow = head;
// 快慢指针同步前进，相交点就是环起点
while (slow != fast) {
fast = fast.next;
slow = slow.next;
}
return slow;
}
}
160.相交链表
- 由于两条链表的长度有可能不想同，两条链表之间的节点无法对应， 如下图所示的链表。如果用两个指针p1和p2分别在两条链表上前进，并不能同时到达公共节点，也就无法得到相交节点c1。
- 所以为了解决这个问题，需要通过某些方式，让p1和p2能够同时到达公共节点c1。如果用两个指针p1和p2分别在两条链表上前进，我们可以让p1遍历完链表A之后开始遍历链表B，让p2遍历完链表B之后开始遍历链表A，这样相当于逻辑上两条链表接在了一起。如果这样进行拼接，就可以让p1和p2同时进入公共部分，也就是同时到达相交点c1。
- 另一种思路，先计算两条链表的长度，然后让p1和p2距离链表尾部的距离相同，然后齐头并进。
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
// p1 指向 A 链表头结点，p2 指向 B 链表头结点
ListNode p1 = headA, p2 = headB;
while (p1 != p2) {
// p1 走一步，如果走到 A 链表末尾，转到 B 链表
if (p1 == null) p1 = headB;
else p1 = p1.next;
// p2 走一步，如果走到 B 链表末尾，转到 A 链表
if (p2 == null) p2 = headA;
else p2 = p2.next;
}
return p1;
}
}
扫一扫
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
