24.两两交换链表中的节点
题目
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
链接:两两交换链表中的节点
思路
注意:不要觉得是按照1234…这样的数字来安排的,不是这种(if(xxx.next.val % 2 == 0)
)
原图:如下图,pre是虚拟头节点
cur.next = second; // 如下图
first.next = second.next; // 如下图
second.next = first; // 如下图
cur = first; // 如下图
ListNode first = cur.next;
ListNode second = cur.next.next; // 如下图
最终:如下图
迭代(创建虚拟头节点)
- 时间复杂度:O(n)
- 空间复杂度:O(1)
class Solution {
public ListNode swapPairs(ListNode head) {
//创建虚拟头节点
ListNode pre = new ListNode(0);
pre.next = head;
ListNode cur = pre;
//循环,确保下一个和下下一个节点的存在
while(cur.next != null && cur.next.next != null){
//看图
ListNode first = cur.next;
ListNode second = cur.next.next;
cur.next = second;
first.next = second.next;
second.next = first;
cur = first;
}
return pre.next;
}
}
递归
- 时间复杂度:O(n)
- 空间复杂度:O(1)
class Solution {
public ListNode swapPairs(ListNode head) {
if(head == null || head.next == null) return head;
// 获取当前的下一个节点
ListNode node = head.next;
// 进行递归
ListNode newNode = swapPairs(node.next);
// 开始交换
node.next = head;
head.next = newNode;
return node;
}
}
19.删除链表的倒数第N个节点
题目
给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
链接:删除链表的倒数第N个节点
计算长度
思路
计算链表长度,在通过总数 - 倒数删除的节点数 + 1,就可以定位到删除节点的前一个位置
- 时间复杂度:O(count),count是链表的长度
- 空间复杂度:O(1)
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
//创建虚拟头节点
ListNode pre = new ListNode(0);
pre.next = head;
//计算有多少个节点
int count = 0;
while(head != null){
count++;
head = head.next;
}
ListNode temp = pre;
//count - n + 1,可以直接将结点传到要删除的节点的上一个节点
int i = 1;
while(i < count - n + 1){
temp = temp.next;
i++;
}
/*for(int i = 1; i < count - n + 1; i++){
temp = temp.next;
}*/
//删除节点
temp.next = temp.next.next;
ListNode ans = pre.next;
return ans;
}
}
双指针法1
思路
- 时间复杂度:O(n),n是链表的长度
- 空间复杂度:O(1)
原图:如下图
// 如下图
for(int i = 1; i <= n; i++){ first = first.next; }// n=2
// 如下图
while(first != null){ second = second.next; first = first.next; }
// 如下图
second.next = second.next.next;
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
//创建虚拟节点
ListNode dur = new ListNode(0);
dur.next = head;
// ListNode dur = new ListNode(0, head);
ListNode first = dur.next;
ListNode second = dur;
//倒数多少位,就将first向前几位
for(int i = 1; i <= n; i++){
first = first.next;
}
while(first != null){
second = second.next;
first = first.next;
}
second.next = second.next.next;
ListNode ans = dur.next;
return ans;
}
}
双指针法2
思路
- 时间复杂度:O(n),n是链表的长度
- 空间复杂度:O(1)
// 如下图
ListNode temp = new ListNode(0);
temp.next = head;
ListNode slow = temp;
ListNode fast = temp;
// 如下图
for(int i = 0; i < n; i++){ fast = fast.next; } // n = 2
// 如下图
while(fast.next != null){ slow = slow.next; fast = fast.next; }
// 如下图
slow.next = slow.next.next;
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode temp = new ListNode(0);
temp.next = head;
ListNode slow = temp;
ListNode fast = temp;
for(int i = 0; i < n; i++){
fast = fast.next;
}
while(fast.next != null){
slow = slow.next;
fast = fast.next;
}
slow.next = slow.next.next;
return temp.next;
}
}
02.07. 链表相交
题目
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
图示两个链表在节点 c1 开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
链接:链表相交
双指针法
- 时间复杂度:O(ha + hb),ha,hb是链表headA,headB的长度
- 空间复杂度:O(1)
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode Ha = headA;
ListNode Hb = headB;
while (Ha != Hb) {
Ha = Ha != null ? Ha.next : headB;
Hb = Hb != null ? Hb.next : headA;
}
return Ha;
}
}
141.环形链表
题目
给你一个链表的头节点 head ,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ,则返回 true 。 否则,返回 false 。
链接:环形链表
快慢指针法(双指针法1)
思路
- 判断链表是否环
- 如果有环,如何找到这个环的入口
- 时间复杂度: O(n),快慢指针相遇前,指针走的次数小于链表长度,快慢指针相遇后,两个index指针走的次数也小于链表长度,总体为走的次数小于 2n
- 空间复杂度: O(1)
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while(fast != null && fast.next != null){
// 走一步
slow = slow.next;
// 走两步
fast = fast.next.next;
// 有环
if(slow == fast){
// slow和fast相遇的节点
ListNode index1 = fast;
// 头节点
ListNode index2 = head;
// 相遇节点和头节点在未遇见之前各走一步,直到相遇为止
while(index1 != index2){
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}
快慢指针法(双指针法2)(不符合题意)
思路
设定两个节点,一前一后,在经过循环时,前面的结点要比后面的节点走得更快,如果是环形链表,则走得快的节点会遇到走得慢的节点,如果不是环形链表,则两个节点不会遇到
- 时间复杂度:O(n)
- 空间复杂度:O(1)
原图:如下图
//进入循环后,如下图:
slow = slow.next; //走一步
fast = fast.next.next; //走两步
循环一次:如下图
循环两次:如下图
循环三次(遇到了):如下图
public class Solution {
public boolean hasCycle(ListNode head) {
//判断链表是否为空
if(head == null || head.next == null){
return false;
}
//确定快慢指针
ListNode slow = head;
ListNode fast = head.next;
while(slow != fast){
if(fast == null || fast.next == null){
return false;
}
//走一步
slow = slow.next;
//走两步
fast = fast.next.next;
}
return true;
}
}
补充:环形链表
有环的情况下,如何找到环的入口
前提条件
- 从头结点到环形入口节点 的节点数为x。
- 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。
- 从相遇节点再到环形入口节点节点数为z。