[代码随想录算法训练营]刷题笔记 Day 4

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

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode();
        dummy->next = head;
        ListNode* cur = dummy;

        while(cur->next != NULL && cur->next->next != NULL){
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = temp1;
            cur->next->next->next = temp2;

            cur = cur->next->next;
        }

        return dummy->next;

    }
};

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

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0, head);
        ListNode* fast = dummy;
        ListNode* slow = dummy;
        
        n++;

        while(n-- && fast != nullptr){
            fast = fast->next;
        }

        while(fast != nullptr){
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete(temp);

        return dummy->next;
    }
};

面试题 02.07. 链表相交

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* fastA = headA;
        ListNode* fastB = headB;

        while(fastA != NULL && fastB != NULL){
            fastA = fastA->next;
            fastB = fastB->next;
        }

        ListNode* slowA = headA;
        ListNode* slowB = headB;

        while(fastA !=  NULL){
            slowA = slowA->next;
            fastA = fastA->next;
        }

        
        while(fastB !=  NULL){
            slowB = slowB->next;
            fastB = fastB->next;
        }

        while(slowA != slowB){
            slowB = slowB->next;
            slowA = slowA->next;
        }

        return slowA;
    }
};

142.环形链表II

若链表有环，那么快指针一定会追上慢指针。而设定快指针每次走比慢指针多一步，有两个好处：一、快指针步会跳过慢指针，因为从相对来讲相当于慢指针静止步动而快指针一步一步追上慢指针。二、慢指针进入环中并不会走到完整一圈后才被追上，因为快指针式慢指针的两倍速，快指针会走两圈如果慢指针走完一圈，而结合前面一点，快指针不可能跳过慢指针走完两圈，所以慢指针必定步会走完一整圈。

结合上述，我们写出快慢指针的关系式，我们可以发现从头节点出发跟从刚刚快慢指针相遇点出发，这两格节点必定在环的开始点相遇。

x = (n-1)(y+z) + z

x是头节点到环入口的距离

y是从环入口到快慢指针相遇点的距离

z是从快慢指针相遇点到环入口的距离

class Solution {
public:
	ListNode *detectCycle(ListNode *head) {
		ListNode* fast = head;
		ListNode* slow = head;
		ListNode* result = nullptr;

		while(fast != nullptr && fast->next != nullptr){
			fast = fast->next->next;
			slow = slow->next;
			if(fast == slow){
				ListNode* index1 = fast;
				ListNode* index2 = head;

				while(index1 != index2){
					index1 = index1->next;
					index2 = index2->next;
				}

				result = index1;
				break;
			}
			
		}

		return result;
	}
};