代码随想录算法训练营第46期 Day4

Leetcode 24.两两交换链表中的节点

/**
 * 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();//借用录友的一句话，头节点特殊性在于没有前一个节点可以指向他，而中间节点有前后节点，加上虚拟头节点就是把真正的头节点当作中间的节点来处理；
dummyHead->next=head;
ListNode* curr=dummyHead;
while(curr->next!=NULL&&curr->next->next){
    //提前设置两个temp临时变量，用来节点的转向，不然有的节点会失去链接，下面以具体例子介绍
ListNode* tep=curr->next;//这里存一号节点
ListNode* tep1=curr->next->next->next;//这里存三号节点
curr->next=curr->next->next;//虚拟头节点指向二号节点，即将二号节点设为头节点，也即二号节点以经到了原来一号节点的位置了
curr->next->next=tep;//二号节点指向一号节点
curr->next->next->next=tep1;//一号节点指向三号节点，完成交换
curr=curr->next->next;//当前节点往后移动两位，进行下一轮交换。第一次运行的时候忘记写这一条导致超时了
}
return dummyHead->next;//返回虚拟节点的下一个节点，也就是现在的头节点
    }
};

Leetcode 19.删除链表的倒数第k个节点

又到了我们最喜爱的双指针环节，我们始终保持快指针比慢指针提前k个单位，那么当快指针走到结束位置的时候，慢指针就是链表的倒数第k个节点

先给大家贴一下，我的丑陋的代码

/**
 * 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* slow=head;
ListNode* fast=head;
ListNode* dummyHead=new ListNode();//虚拟头节点，你是我的神
ListNode* record=dummyHead;//让record代替虚拟头节点遍历链表
dummyHead->next=head;//同时也是record->next=head;这样就保证了从头到尾record始终在slow指针前面一位
while(fast&&n--){//我们始终保持快指针比慢指针提前k个单位，那么当快指针走到结束位置的时候，慢指针就是链表的倒数第k个节点
fast=fast->next;
}
while(fast){//这样的写法其实是三指针，最开始是record,record下一位就是slow,slow之后k个单位是fast
    fast=fast->next;
    record=record->next;
    slow=slow->next;
}
record->next=slow->next;//删除倒数第k个元素


return dummyHead->next;
    }
};

下面给大家贴一下更正宗的双指针

/**
 * 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();//虚拟头节点，你是我的神
ListNode* slow=dummyHead;
ListNode* fast=dummyHead;
dummyHead->next=head;//同时也是record->next=head;这样就保证了从头到尾record始终在slow指针前面一位
while(fast&&n--){
fast=fast->next;
}
fast=fast->next;//因为最开始fast在虚拟头指针的位置所有这里要让fast多走一步
while(fast){
    fast=fast->next;
    slow=slow->next;
}
//这样执行下来，slow的位置处在倒数第k个节点前一位，因此不需要record的辅助，可以直接删除第k个元素了
slow->next=slow->next->next;//删除倒数第k个元素


return dummyHead->next;
    }
};

面试题：链表相交

玛雅，这要是面试我就寄了,一开始想用哈希无脑算，这次又是双指针。要注意相交之后自交点开始所有值都是相同的！！！！警示后人！！！！！！

/**
 * 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* cura=headA;//我们理解了题意之后发现，两个链表需要做一个尾端对其，因为他们相交节点后任何一个节点都是相等的，也就是相同的一个子链
    ListNode* curb=headB;
    int a=0,b=0;
    while(cura){
        a++;
        cura=cura->next;
    }
     while(curb){
        b++;
        curb=curb->next;
    }
    cura=headA;
    curb=headB;
    int sub=a-b;//一直到这里都是在算a，b两链表长度差多少
if(sub>0){
    while(sub--){
        cura=cura->next;
    }
}else{
    while(sub++){
        curb=curb->next;
    }
}//上述的if，else代码就是给两个链表做尾端对齐
while(cura&&curb){
    if(cura==curb){//这里太妙了，直接相等就解决了如何判断此节点相等后，后续节点是否相等的问题了
        return cura;
    }
    cura=cura->next;
    curb=curb->next;
}
return NULL;
    }
};

下面附带一些哈希的解法，用哈希的话比较慢，但也是官方解法之一

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set <ListNode*>  hash;
        ListNode* curA = headA;
        ListNode* curB = headB;
        while(curA != NULL){
            hash.insert(curA);
            curA = curA->next;
        }
        while(curB != NULL){
            if(hash.find(curB) != NULL){
                return curB;
            }else{
                curB = curB->next;
            }
        }
        return NULL;
    }
};

LeetCode 142.环形链表Ⅱ

依旧是一道哈希和双指针都可以做的题，哈希的话其实相当于水过去了，主要还是练练双指针。

哈希：

这里哈希的思路就是，每到一个节点都检查这个节点开始有没有成环，如果没有就插入，有就返回这个节点。

/**
 * 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) {
         unordered_set <ListNode*>  hash;
        ListNode* curr= head;
   
        while(curr != NULL){
            if(hash.find(curr) != NULL){
                return curr;
            }
            hash.insert(curr);
                curr = curr->next;
        }
        
        return NULL;
    }
    };

双指针：

我们设置快慢指针，其中快指针一次跳跃两步，慢指针一次跳跃一步。如果快指针一路跳到空那说明这就是个无环链表，直接返回空就可以。

如果有环的话，快慢指针一定会在环上相遇（相遇指快慢指针跳完之后所在位置一样）。

相遇之后，快指针回到开头，并将快指针改为一次跳跃一步，慢指针不移动仍然在相遇节点处，仍然是一次跳跃一步。

当快慢指针再次相遇时，便是入环节点处。

贴一下卡哥的代码

/**
 * 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 = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
    
    };