本文介绍了四个关于链表的操作问题，包括两两交换链表中的结点、删除链表的倒数第N个结点、查找两个链表的相交节点以及检测环形链表。解题策略涉及到双指针、链表长度计算和节点交换等技巧，确保不修改链表内部值并保持原始结构。
24.两两交换链表中的结点
题目描述
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：输入：head = []
输出：[]
示例 3：输入：head = [1]
输出：[1]
提示：链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
问题分析
- 给定一个链表，两两交换其中相邻的结点，链表的结点数有可能是奇数也可能是偶数；
- 不能直接交换结点对应的值，而是直接交换结点
解法思路
这道题就按照题目的要求进行模拟就可以了，首先循环条件一定要兼顾结点数是奇数和结点数是偶数的情况；其次在交换同时，注意一些结点的会丢失，一定要提前创建临时结点保存；
示例代码
c语言
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* swapPairs(struct ListNode* head){
struct ListNode *dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
dummy->next = head;
struct ListNode *cur = dummy;
while(cur->next!=NULL&&cur->next->next!=NULL)
{
struct ListNode *temp1 = cur->next;
struct ListNode *temp2 = cur->next->next->next;
cur->next = cur->next->next;
cur->next->next = temp1;
cur->next->next->next = temp2;
cur = cur->next->next;
}
return dummy->next;
}java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dummy = new ListNode();
dummy.next = head;
ListNode cur = dummy;
while(cur.next != null && cur.next.next != null){
ListNode temp1 = cur.next;
ListNode temp2 = cur.next.next.next;
cur.next = cur.next.next;
cur.next.next = temp1;
cur.next.next.next = temp2;
cur = cur.next.next;
}
return dummy.next;
}
}19.删除链表的倒数第N个结点
题目描述
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：输入：head = [1], n = 1
输出：[]
示例 3：输入：head = [1,2], n = 1
输出：[1]
提示：链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
进阶：你能尝试使用一趟扫描实现吗？
问题分析
- 给出一个链表，删除该链表的倒数第N个结点；
解法思路
采用双指针的思想，创建fast和slow指针，fast指针先走n+1步，然后fast指针和slow指针同时走，当fast指针为空的时候，slow指针刚好指向要删除结点的前一个结点，直接让指针指向要删除结点的下一个结点即可；
示例代码
c语言
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
typedef struct ListNode* node;
node dummy = (node)malloc(sizeof(struct ListNode));
dummy->next = head;
node fast = dummy;
node slow = dummy;
while(n--)
{
fast = fast->next;
}
fast = fast->next;
while(fast)
{
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
head = dummy->next;
return head;
}java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode();
dummy.next = head;
ListNode fast = dummy;
ListNode slow = dummy;
while(n-->0)
{
fast = fast.next;
}
fast = fast.next;
while(fast!=null)
{
fast = fast.next;
slow = slow.next;
}
slow.next = slow.next.next;
return dummy.next;
}
}面试题02.07.链表相交
题目描述
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,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 。
提示：
listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]
进阶：你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？
问题分析
-
给定两个链表，判断链表是不是相交，如果相交，返回相交的节点，如果无，返回null；
-
不能改变链表的结构
解法思路
先分别计算出两个链表的长度，然后计算出长度的差值，用两个指针分别指向两个链表；长链表的指针先走，直到长链表与短链表的尾部对齐，然后判断两个指针同时走，判断何时两个指针指向的地址相同，如果相同，直接返回指向的结点，如果没有，则返回空；
示例代码
c语言
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
struct ListNode *l = NULL,*s = NULL;
int lenA = 0,lenB = 0,gap = 0;
s = headA;
while(s){
lenA++;
s = s->next;
}
s = headB;
while(s){
lenB++;
s = s->next;
}
if(lenA > lenB)
{
l = headA;
s = headB;
gap = lenA-lenB;
}
else
{
l = headB;
s = headA;
gap = lenB-lenA;
}
while(gap--)
l = l->next;
while(l)
{
if(l == s)
return l;
l = l->next;
s = s->next;
}
return NULL;
}java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode l = null;
ListNode s = null;
int lenA=0,lenB=0,gap=0;
s = headA;
while(s!=null){
s = s.next;
lenA++;
}
s = headB;
while(s!=null){
s = s.next;
lenB++;
}
if(lenA > lenB)
{
l = headA;s = headB;
gap = lenA - lenB;
}else{
l = headB;s = headA;
gap = lenB- lenA;
}
while(gap-->0)
l = l.next;
while(l!=null)
{
if(l==s)
return l;
l = l.next;
s = s.next;
}
return null;
}
}142.环形链表
题目描述
给定一个链表的头节点 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
解释：链表中没有环。
提示：链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
进阶：你是否可以使用 O(1) 空间解决此题？
问题分析
- 首先给定一个链表，先判断这个链表是否有环；
- 如果有环，判断该环的起始结点，然后返回；
- 不能改变原链表；
解法思路
可以用快慢双指针来判断链表中是否有环，快指针一次走两步，慢指针一次走一步，如果有环，那么快慢指针一定会在环中相遇，相当于快指针在追慢指针；如何寻找环的其实位置呢，这个过程需要一些简单的推理，结论是：从头结点出发一个指针，从快慢指针相遇结点也出发一个指针，着两个指针每一次走一个结点，当这两个指针相遇的时候就是环形入口的结点；
示例代码
c语言
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *detectCycle(struct ListNode *head) {
typedef struct ListNode * node;
node fast = head;
node slow = head;
while(fast&&fast->next)
{
fast = fast->next->next;
slow = slow->next;
if(fast==slow)
{
node index1 = fast;
node index2 = head;
while(index1!=index2)
{
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
}
return NULL;
}java
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
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(fast == slow)
{
ListNode index1 = fast;
ListNode index2 = head;
while(index1 != index2)
{
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}今日总结
今天对链表的一些其他操作有了更深刻的理解，在做删除链表的倒数第N个结点的时候，又结合了前面学过的双指针，在操作的链表的同时，对双指针的思想有了更清楚的认识；
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
