24. 两两交换链表中的节点
思路
想要使用虚拟头结点,统一代码
解题方法
设置一个虚拟头结点,设立一个临时指针(因为最后需要返回头指针)指向虚拟头结点,再设立两个临时节点保存第一个和第二个节点的值。(必须要保存,否则无法找到这两个节点的值)
![](https://i-blog.csdnimg.cn/blog_migrate/e323bd02a918475760a82b01164808a9.png)
复杂度
时间复杂度O(n)
空间复杂度O(1)
Code
/**
* 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 *tmp=cur->next;
ListNode *tmp1=cur->next->next->next;
cur->next=cur->next->next;
cur->next->next=tmp;
cur->next->next->next=tmp1;
cur=cur->next->next;
}
return dummyhead->next;
}
};
19.删除链表的倒数第N个节点
思路
先想到的是设置虚拟头结点,统一代码。然后设置两个临时指针,一个fast,一个slow。
解题方法
要想删除倒数第n个节点,首先要找到这个节点的前一个节点。 让fast先走n个节点,然后再让俩指针同时走,这样等到fast走到最后一个节点时,slow恰好走到要删除的倒数第n个节点的前一个节点,让slow->next=slow->next->next;就解决了。注意指针不能为空,要进行判断。
![](https://i-blog.csdnimg.cn/blog_migrate/9b00a49312037c9bda784a5f64686073.png)
复杂度
时间复杂度O(n)
空间复杂度O(1)
Code
/**
* 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!=NULL)
{
fast=fast->next;
}
while(fast->next!=nullptr)
{
fast=fast->next;
slow=slow->next;
}
slow->next=slow->next->next;
return dummyhead->next;
}
};
面试题 02.07. 链表相交
思路
让两个链表的尾部对齐再遍历,比较的是指针是否相等,不是数值是否相等。
解题方法
计算两个链表的长度,将长的那个记为A,求出lenA-lenB的值,记为n,然后让A走过n个节点,然后让curA和curB同时开始遍历,比较curA和curB是否相等,若相等,则返回curA;
![](https://i-blog.csdnimg.cn/blog_migrate/7b56a7f91e75365f5f7bcab0f563dc9c.png)
复杂度
时间复杂度O(n+m)
空间复杂度O(1)
Code
/**
* 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) {
int lenA=0;
int lenB=0;
ListNode *curA=headA;
ListNode *curB=headB;
while(curA!=NULL)
{
curA=curA->next;
lenA++;
}
while(curB!=NULL)
{
curB=curB->next;
lenB++;
}
curA=headA;
curB=headB;
if(lenB>lenA)
{
swap(lenA,lenB);
swap(curA,curB);
}
int n=lenA-lenB;
while(n--&&curA!=NULL)
{
curA=curA->next;
}
while(curA!=NULL)
{
if(curA==curB)
{
return curA;
}
curA=curA->next;
curB=curB->next;
}
return NULL;
}
};
142.环形链表II
思路
定义快慢指针
解题方法
定义快慢指针
![](https://i-blog.csdnimg.cn/blog_migrate/e14e68afeb1294476311a9da96f29cee.png)
复杂度
时间复杂度O(n)
空间复杂度O(1)
Code
/**
* 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 *fast=new ListNode(0);
ListNode *slow=new ListNode(0);
fast=head;
slow=head;
while(fast!=NULL&&fast->next!=NULL)
{
fast=fast->next->next;
slow=slow->next;
if(slow==fast)
{
ListNode *index1=fast;
ListNode *index2=head;
while(index1!=index2)
{
index1=index1->next;
index2=index2->next;
}
return index2;
}
} return NULL;
}
};