代码随想录算法训练营第四天|24.两两交换链表中的节点

题目链接：24. 两两交换链表中的节点

视频讲解：

题解：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//递归版本
struct ListNode* swapPairs(struct ListNode* head){
    //递归结束条件：头节点不存在或头节点的下一个节点不存在。此时不需要交换，直接返回head
    if(!head || !head->next)
        return head;
    //创建一个节点指针类型保存头结点下一个节点
    struct ListNode *newHead = head->next;
    //更改头结点+2位节点后的值，并将头结点的next指针指向这个更改过的list
    head->next = swapPairs(newHead->next);
    //将新的头结点的next指针指向老的头节点
    newHead->next = head;
    return newHead;
}

//非递归版本：
struct ListNode* swapPairs(struct ListNode* head){
    //使用双指针避免使用中间变量
    typedef struct ListNode ListNode;
    ListNode *fakehead = (ListNode *)malloc(sizeof(ListNode));//虚拟头结点
    fakehead->next = head;
    ListNode* right = fakehead->next;
    ListNode* left = fakehead;
    while(left && right && right->next ){
        left->next = right->next;
        right->next = left->next->next;
        left->next->next = right;
        left = right;
        right = left->next;
    }
    return fakehead->next;
}

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

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

题解：

/**c语言单链表的定义
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    //定义虚拟头节点dummy 并初始化使其指向head
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    //定义 fast slow 双指针
    struct ListNode* fast = head;
    struct ListNode* slow = dummy;

    for (int i = 0; i < n; ++i) {
        fast = fast->next;
    }
    while (fast!=NULL) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;//删除倒数第n个节点
    head = dummy->next;
    free(dummy);//删除虚拟节点dummy
    return head;
}

为什么要用malloc为dummyhead开空间？

dummy 被动态分配内存的原因是为了创建一个虚拟头节点。这个虚拟头节点用于简化链表的操作，因为在删除倒数第 n 个节点时，我们需要访问倒数第 n+1 个节点，但如果链表为空或者只有一个节点，就没有倒数第 n+1 个节点。因此，为了处理这种情况，我们引入了虚拟头节点，它不包含有效数据，但可以确保链表永远不为空。

在这种情况下，使用 malloc 分配内存是必要的，因为我们需要在堆上动态创建一个新的节点，并在其上设置 val 和 next 成员的值，以使其成为虚拟头节点。

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

题解：

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *l = NULL, *s = NULL;
    int lenA = 0, lenB = 0, gap = 0;
    // 求出两个链表的长度，记为lenA和lenB
    s = headA;
    while (s) {
        lenA ++;
        s = s->next;
    }
    s = headB;
    while (s) {
        lenB ++;
        s = s->next;
    }

    // 求出两个链表长度差
    if (lenA > lenB) {
        l = headA, s = headB;
        gap = lenA - lenB;
    } else {
        l = headB, s = headA;
        gap = lenB - lenA;
    }

    // 尾部对齐
    while (gap--) l = l->next;
    // 移动，并检查是否有相同的元素
    while (l) {
        if (l == s) return l;
        l = l->next, s = s->next;
    }

    return NULL;
}

交点不是数值相等，而是指针相等。因为第一条的第二个和第二条的第八个相等也没用

为什么不用malloc为l和s开空间？

l 和 s 是指向两个链表的指针，它们不需要额外的内存来存储数据，因为它们只是用来遍历已经存在的链表。这两个指针只是引用链表中的节点，它们不需要额外的内存来存储节点的数据。这就是为什么在第二个程序中没有使用 malloc 分配内存的原因。

题目链接：142.环形链表

视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

题解：