代码随想录二刷——链表day4

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划二刷完卡子哥的刷题计划，加油！
二刷决定精刷了，于是参加了卡子哥的刷题班，训练营为期60天，我一定能坚持下去，迎来两个月后的脱变的，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

链表知识点

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链表的入口节点称为链表的头结点也就是head。
链表分为单链表、双链表、循环链表
链表在内存中储存不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

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

24. 两两交换链表中的节点
Note：画图模拟吧。。。

/**
 * 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 != NULL && cur->next->next != NULL) {
            ListNode* tmp = cur->next;
            ListNode* pre = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = pre;

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

二、19. 删除链表的倒数第 N 个结点

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

Note：快慢指针操作

/**
 * 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* fast = dummyHead;
        ListNode* slow = dummyHead;

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

        return dummyHead->next;
    }
};

三、面试题 02.07. 链表相交

面试题 02.07. 链表相交

Note：对齐，然后遍历

/**
 * 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, lenB = 0;

        while (curA != NULL) {
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) {
            lenB++;
            curB = curB->next;
        }

        curA = headA;
        curB = headB;

        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }

        int value = lenA - lenB;

        while (value--)
            curA = curA->next;

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

四、142. 环形链表 II

142. 环形链表 II

Note：每一次看到这个方法都觉得真的巧妙

/**
 * 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) {
            fast = fast->next->next;
            slow = slow->next;

            if (fast == slow) {
                ListNode* Index1 = head;
                ListNode* Index2 = fast;

                while (Index1 != Index2) {
                    Index1 = Index1->next;
                    Index2 = Index2->next;
                }
                return Index2;
            }
        }
        return NULL;
    }
};

总结

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。