给定一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例
示例 1:
输入: head = [1,2,3,4]
输出:[2,1,4,3]
示例 2:
输入:head = []
输出:[]
示例 3:
输入:head = [1]
输出:[1]
提示
[0, 100]
内0 <= Node.val <= 100
比较常规的题目,加一个虚拟头节点然后理清楚交换逻辑就行。代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyhead = new ListNode(0);
dummyhead->next = head;
ListNode* cur = dummyhead;
while(cur->next != nullptr && cur->next->next != nullptr) {
ListNode* temp1 = cur->next;
ListNode* temp2 = cur->next->next->next;
cur->next = cur->next->next;
cur->next->next = temp1;
temp1->next = temp2;
cur = cur->next->next;
}
return dummyhead->next;
}
};
给你一个链表,删除链表的倒数第 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]
示例 3:
输入:head = [1,2], n = 1
输出:[1]
提示
sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
双指针的经典应用,要删除倒数第 n 个结点,那我们就让快指针先走n个节点,然后快慢指针同时走,直到快指针指向链表末尾,这时候删掉慢指针指向的节点就可以。代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyhead = new ListNode(0);
dummyhead->next = head;
ListNode* slow = dummyhead;
ListNode* fast = dummyhead;
while(n-- && fast != nullptr) {
fast = fast->next;
}
fast = fast->next;
while(fast != nullptr) {
slow = slow->next;
fast = fast->next;
}
slow->next = slow->next->next;
return dummyhead->next;
}
};
给你两个单链表的头节点 headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
图示两个链表在节点 c1
开始相交:
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 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
输出:Reference of the node with value = 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。
提示:
我们发现如果两个链表有相交节点,那他相交节点后的链表一定是相同的。所以先求出两个链表长度的差值,然后比较后续链表是否相同,由于链表是无环的,所以遇到相同节点直接返回就是要的结果。代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* dummyhead = new ListNode(0);
ListNode* cura = headA;
ListNode* curb = headB;
int lena = 0;//链表长度
int lenb = 0;
while(cura->next != nullptr){
lena++;
cura = cura->next;
}
while(curb->next != nullptr){
lenb++;
curb = curb->next;
}
cura = headA;
curb = headB;
if(lena < lenb){//得到链表差值,使A链表永远是较长的那一个
swap(cura,curb);
swap(lena,lenb);
}
int gap = lena - lenb;
while(gap--){//让链表cura和curb在同一起点上
cura = cura->next;
}
while(cura != nullptr){//开始比较
if(cura == curb){
return cura;
}
cura = cura->next;
curb = curb->next;
}
return 0;
}
};
给定一个链表的头节点 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, 10^4]
-10^5 <= Node.val <= 10^5
pos
为 -1
或者链表中的一个有效索引。这道题有两个工作,分析是否环;如果有环要找到这个环的入口。
是否环: 可以使用快慢指针法,
slow
指针每次移动一个节点,fast
指针每次移动两个节点,通过遍历链表,如果最终fast指针指向nullptr
则无环,如果slow和fast指针相遇,则说明有环。
环的入口需要一些数学运算:慢指针走过的节点数为:x+y
,快指针走过的节点数为x+y+n*(y+z)
,于是列出等式:2*(x+y)=x+y+n*(y+z)
,化简后得到x=(n-1)*(y+z)+z
,这说明x节点数等于z节点数加(n-1)环。所以我们找环入口节点就变成了让快慢指针分别从相遇节点和head节点出发,每次移动一个节点,最终相遇的节点就是环形入口节点。
代码如下:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* slow = head;
ListNode* fast = head;
while(fast != nullptr && fast->next != nullptr) {
slow = slow->next;//慢指针移动一个节点
fast = fast->next->next;//快指针移动两个节点
if(slow == fast) {//快慢指针相遇
slow = head;//相遇后慢指针重新回到起点
while(fast != slow) {
fast = fast->next;//快慢指针均移动一个节点
slow = slow->next;
}
return fast;
}
}
return nullptr;
}
};