24. 两两交换链表中的节点
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
图示:
就是要new一个哑节点(dummyHead),然后cur = hummyHead;然后步骤1,即哑节点的下一个是节点2,cur->next = cur->next->next;然后步骤2,但步骤1中cur的next已经变成了2,不是1了,那我们就无法找到节点1了,于是我们要一开始那一个temp1去标记一下节点1,即temp1 = cur->next让节点2去指向节点1,也就是cur->next->next = temp1;但此时也有同样的问题,那就是节点3也会因为节点2改变指向而丢失,所以节点3我们也要在一开始就标记一下,于是temp2 = cur->next->next->next;这样我们就可以执行上述步骤了。
判断循环什么时候终止:我们是通过cur去操作后面的两个节点进行交换。如果是链表是奇数个,那么cur后来就会有next,但cur->next->next就为空,结束。如果链表为偶数个,那么cur的next就是空,结束。所以循环的终止条件就是cur->next!= nullptr 和cur->next->next!= nullptr.
那为什么是&& 不是|| 呢?一个是对于偶数个结点的判断 一个是奇数个结点 那不应该是||的关系吗?
奇数节点就不需要交换了,所以只有满足后面有偶数个节点的时候才会进入循环
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummyHead = new ListNode(0,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;
}
};
19.删除链表的倒数第N个节点
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
方法1:
首先获取链表长度,根据长度找到要删除的节点的前一个节点,删除对应节点。
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(-1,head);
ListNode* cur = dummyHead;
int count = 0;
while(cur->next!= nullptr){
cur = cur->next;
count++;
}
int k = count-n;
cur = dummyHead;
while(k){
cur = cur->next;
k--;
}
ListNode* temp = cur->next;
cur->next = temp->next;
delete temp;
return dummyHead->next;
}
};
方法2:
双指针,让快指针先走n步,然后快慢指针在同时往后走,等快指针结束时,满指针到达指定地点,再进行链表操作。
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(-1,head);
ListNode* fast = dummyHead;
ListNode* slow = dummyHead;
while(n--){
fast = fast->next;
}
while(fast->next!= nullptr){
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
return dummyHead->next;
}
};
面试题 02.07. 链表相交
方法1:
将链表A节点插入哈希表 中,然后遍历链表B去查找。
时间复杂度:O(m+n)O(m+n)O(m+n),其中 mmm 和 nnn 是分别是链表 headA\textit{headA}headA 和 headB\textit{headB}headB 的长度。需要遍历两个链表各一次。
空间复杂度:O(m)O(m)O(m),其中 mmm 是链表 headA\textit{headA}headA 的长度。需要使用哈希集合存储链表 headA\textit{headA}headA 中的全部节点
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
unordered_set<ListNode*> st;
ListNode* cur1 = headA;
while(cur1!= nullptr){
st.insert(cur1);
cur1 = cur1->next;
}
ListNode* cur2 = headB;
while(cur2!= nullptr){
if(st.find(cur2)!= st.end()){
return cur2;
}
cur2 = cur2->next;
}
return nullptr;
}
};
方法2:
遍历两个链表长度,相减之后,长的先走几步,然后同时走,相遇时即为相交节点
class Solution {
public:
int ListLength(ListNode* head){
if(head == nullptr)return 0;
ListNode* cur = head;
int count = 0;
while(cur!= nullptr){
count++;
cur = cur->next;
}
return count;
}
ListNode* compare1(ListNode *headA,int lengthA, ListNode *headB,int lengthB){
int n = lengthA-lengthB;
ListNode* curA = headA;
ListNode* curB = headB;
while(n--){
curA =curA->next;
}
while(curA!= nullptr){
if(curA == curB){
return curA;
}
curA = curA->next;
curB = curB->next;
}
return nullptr;
}
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
int lengthA = ListLength(headA);
int lengthB = ListLength(headB);
if(lengthA>lengthB){
ListNode* ans= compare1(headA,lengthA, headB,lengthB);
return ans;
}
if(lengthB>=lengthA){
ListNode* ans= compare1(headB,lengthB, headA,lengthA);
return ans;
}
return nullptr;
}
};
142.环形链表II
给定一个链表的头节点 head
,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
如果链表中有某个节点,可以通过连续跟踪 next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos
是 -1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
方法1:哈希
借用unordered_set,将节点插入哈希表,判断下一个节点是否之已经在哈希表中,如果有,就有环,并返回该节点,反之就是没有环。时间复O(n),空间复杂度也为O(n)
lass Solution {
public:
ListNode *detectCycle(ListNode *head) {
unordered_set<ListNode*> st;
ListNode* cur = head;
while(cur!= nullptr){
if(st.find(cur)!= st.end()){
return cur;
}else{
st.insert(cur);
cur = cur->next;
}
}
return nullptr;
}
};
方法2:双指针-快慢指针
双指针方法
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast!= nullptr && fast->next!= nullptr){
fast = fast->next->next;
slow = slow->next;
if(fast == slow){
ListNode* temp1 = head;
ListNode* temp2 = slow;
while(temp1!= temp2){
temp1 = temp1->next;
temp2 = temp2->next;
}
return temp2;
}
}
return nullptr;
}
};