代码随想录算法训练营Day4

代码随想录算法训练营Day4 | 24.两两交换链表的节点、

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* dummy = new ListNode(-1);
        ListNode* cur = dummy;
        dummy->next = head;
        while(cur->next!=NULL && cur->next->next!=NULL){
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;
            cur->next = tmp1->next;
            cur->next->next = tmp1;
            tmp1->next = tmp2;
            cur = cur->next->next;
        }
    return dummy->next;
    }
};

19.删除链表的倒数第N个结点 题目链接

删除节点的关键是找到待删除节点的前一个结点，此处采用快慢指针，快指针走n+1步，快慢指针再同步走sz-n步，慢指针指向第sz-n个结点，即倒数第n+1个结点，为第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* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* fast = head;
        ListNode* slow = dummy;
        while(n--){
            fast = fast->next;
        }
        while(fast!=nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummy->next;

    }
};

面试题 02.07. 链表相交 题目链接

该题的关键在于两个链表同步比较，首先需要确定两个链表的长度，再根据长度差按照末尾对齐，从同一起跑线开始寻找相交的节点。

/**
 * 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 lenA=0;
        int lenB=0;
        while(curA!=NULL){
            lenA++;
            curA = curA->next;
        }
        curA = headA;
        while(curB!=NULL){
            lenB++;
            curB = curB->next;
        }
        curB = headB;

        if(lenB>lenA){
            int temp = lenA;
            lenA = lenB;
            lenB = temp;
            curA = headB;
            curB = headA;
        }   // curA指向长的链表的头结点

        int gap = lenA - lenB;
        while(gap--){
            curA = curA->next;
        }

        while(curA!=NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }

        return NULL;



    }
};

142.环形链表II 题目链接

环的判断：快慢指针。

如果无环，则快慢指针无法相遇；如果有环，则快慢指针会相遇！

参考代码随想录中的图示，假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。

设慢指针slow走过的距离为n，则快指针fast走过的距离为2n，有n=x+y和2n=x+y+k(y+z)

故有x+y=k(y+z)，要求的是x，写为x=k(y+z)-y。

由于k≥1，则x=(k-1)(y+z)+z，当k=1时，x=z

说明指针从fast与slow相遇的节点处开始出发，在与从头结点出发的指针相遇时，该处即为环的入口。

/**
 * 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;
            if(slow == fast){
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};