代码随想录四 | 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、160.链表相交、142.环形链表II

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

使用虚拟头节点，cur指向虚拟头结点，然后进行如下三步：

操作之后，链表如下：

递归法 

//递归版本
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;
}

交换前：
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> NULL

第一步：
newHead = 2
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> NULL
^
|
head

第二步：
head->next = 3
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> NULL
^    ^
|    |
head newHead

第三步：
newHead->next = 1
2 -> 1 -> 3 -> 4 -> 5 -> 6 -> 7 -> NULL
     ^    ^
     |    |
   newHead head

第四步：
head->next = swapPairs(3)
2 -> 1 -> 4 -> 3 -> 5 -> 6 -> 7 -> NULL
     ^         ^
     |         |
   newHead     head

第五步：
newHead = 4
2 -> 1 -> 4 -> 3 -> 5 -> 6 -> 7 -> NULL
          ^         ^
          |         |
        newHead     head

第六步：
head->next = 5
2 -> 1 -> 4 -> 3 -> 5 -> 6 -> 7 -> NULL
          ^    ^
          |    |
        newHead head

第七步：
newHead->next = 4
2 -> 1 -> 5 -> 4 -> 3 -> 6 -> 7 -> NULL
               ^    ^
               |    |
             newHead head

第八步：
head->next = swapPairs(5)
2 -> 1 -> 5 -> 4 -> 6 -> 3 -> 7 -> NULL
               ^         ^
               |         |
             newHead     head

第九步：
newHead = 6
2 -> 1 -> 5 -> 4 -> 6 -> 3 -> 7 -> NULL
                    ^         ^
                    |         |
                  newHead     head

第十步：
head->next = 7
2 -> 1 -> 5 -> 4 -> 6 -> 3 -> 7 -> NULL
                    ^    ^
                    |    |
                  newHead head

第十一步：
newHead->next = 6
2 -> 1 -> 5 -> 4 -> 7 -> 6 -> 3 -> NULL
                         ^    ^
                         |    |
                       newHead head

最终结果：
2 -> 1 -> 5 -> 4 -> 7 -> 6 -> 3 -> NULL

java写法

// 递归版本
class Solution {
    public ListNode swapPairs(ListNode head) {
        // base case 退出提交
        if(head == null || head.next == null) return head;
        // 获取当前节点的下一个节点
        ListNode next = head.next;
        // 进行递归
        ListNode newNode = swapPairs(next.next);
        // 这里进行交换
        next.next = head;
        head.next = newNode;

        return next;
    }
} 

迭代法 

struct ListNode* swapPairs(struct ListNode* head){
    //使用双指针避免使用中间变量
    typedef struct ListNode ListNode;//将 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、right 、right->next 不为空指针，则循环会一直执行。
        // 交换相邻节点
        left->next = right->next; 
        right->next = left->next->next; 
        left->next->next = right; 
        left = right; 
        right = left->next; 
    }
    return fakehead->next; // 返回新的头节点
}

原始链表：
1 -> 2 -> 3 -> 4 -> ...

执行 swapPairs() 后的链表：
fakehead -> 2 -> 1 -> 4 -> 3 -> ...

其中，fakehead 是虚拟头节点，其值为空，但指向链表的头节点。

每次循环中，将相邻节点进行交换，直到遍历完所有相邻节点。

循环执行交换过程如下：
第一次循环：
fakehead -> 2 -> 1 -> 3 -> 4 -> ...
            ^         ^
            |         |
           left     right

第二次循环：
fakehead -> 2 -> 1 -> 3 -> 4 -> ...
                     ^         ^
                     |         |
                    left     right

第三次循环：
fakehead -> 2 -> 1 -> 4 -> 3 -> ...
                          ^    ^
                          |    |
                         left right

最终返回 fakehead->next，即新的头节点。

while循环中

初始状态：
left -> A -> B -> right -> C -> D

执行以下语句后，链表变成了：
left -> B -> right -> A -> C -> D

left->next = right->next; // 把 left 的 next 指针指向 right 的下一个节点（即 B -> right）
right->next = left->next->next; // 把 right 的 next 指针指向 left 的下一个节点的下一个节点（即 A -> C）
left->next->next = right; // 把 left 的下一个节点的 next 指针指向 right（即 B -> right -> A -> C）
left = right; // 把 left 指针指向下一对相邻节点的前一个节点（即 A）
right = left->next; // 把 right 指针指向下一对相邻节点的第一个节点（即 C）

java写法

class Solution {
  public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        dumyhead.next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
        ListNode cur = dumyhead;
        ListNode temp; // 临时节点，保存两个节点后面的节点
        ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
        ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            cur.next = secondnode;       // 步骤一
            secondnode.next = firstnode; // 步骤二
            firstnode.next = temp;      // 步骤三
            cur = firstnode; // cur移动，准备下一轮交换
        }
        return dumyhead.next;  
    }
}

题目链接

文章链接

视频链接

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

删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1 输出：[]

示例 3：

输入：head = [1,2], n = 1 输出：[1] 

思路：双指针的经典应用，操作指针由要删除节点的前一个节点直接指向下下一个节点。

如果要删除倒数第n个节点，让fast移动n+1步，然后让fast和slow同时移动，直到fast指向链表末尾。当快指针到达链表末尾时，慢指针刚好位于要删除节点的前一个节点。

快指针的作用是帮助我们找到要删除节点的位置，而慢指针则负责完成节点的删除操作。

• 定义fast指针和slow指针，初始值为虚拟头结点，如图：

（定义虚拟头节点dummyHead就不需要判断要操作的节点是否为头节点，更方便统一） 

• fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图： 

  

• fast和slow同时移动，直到fast指向末尾，如图： 

  

• 删除slow指向的下一个节点(直接指向下下一个节点），如图： 

  

• 时间复杂度: O(n)
• 空间复杂度: O(1)

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    // 定义虚拟头节点dummy并初始化使其指向head
    struct ListNode* dummy = malloc(sizeof(struct ListNode)); // 分配内存空间
    dummy->val = 0; // 初始化节点值
    dummy->next = head; // 虚拟头节点指向链表头部
    // 定义快慢指针
    struct ListNode* fast = dummy; // 快指针指向虚拟头节点
    struct ListNode* slow = dummy; // 慢指针指向虚拟头节点

    // 快指针先向前移动n+1步，使得快指针与慢指针之间有一个间隔为n的距离。
    for (int i = 0; i < n+1; ++i) {
        fast = fast->next;
    }

    // 同时移动快指针和慢指针，直到快指针指向链表末尾(null)、慢指针指向要删除节点的前一个节点。
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    // 将慢指针的next指针指向要删除节点的下一个节点，完成节点的删除操作。
    slow->next = slow->next->next;
    // 更新链表头部指针
    head = dummy->next;
    // 释放虚拟头节点dummy的内存空间，避免内存泄漏问题。
    free(dummy);
    // 返回链表的头部。
    return head;
}

java写法

public ListNode removeNthFromEnd(ListNode head, int n){
    ListNode dummyNode = new ListNode(0);
    dummyNode.next = head;

    ListNode fastIndex = dummyNode;
    ListNode slowIndex = dummyNode;

    // 只要快慢指针相差 n 个结点即可
    for (int i = 0; i <= n  ; i++){ 
        fastIndex = fastIndex.next;
    }

    while (fastIndex != null){
        fastIndex = fastIndex.next;
        slowIndex = slowIndex.next;
    }

    //此时 slowIndex 的位置就是待删除元素的前一个位置。
    //具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
    slowIndex.next = slowIndex.next.next;
    return dummyNode.next;
}

题目链接

文章链接

视频链接

160.链表相交 

给两个单链表的头节点 headA 和 headB ，找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

求两个链表交点节点的指针，交点不是数值相等，而是指针相等。

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点，否则循环退出返回空指针。

• 时间复杂度：O(n + m)
• 空间复杂度：O(1)

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *l = NULL, *s = NULL;// 定义两个指针，l用于指向较长的链表，s用于指向较短的链表
    int lenA = 0, lenB = 0, gap = 0;// 定义变量保存链表A和链表B的长度以及长度差

    // 求出链表A的长度
    s = headA;
    while (s) {
        lenA++;
        s = s->next;
    }

    // 求出链表B的长度
    s = headB;
    while (s) {
        lenB++;
        s = s->next;
    }

    // 判断哪个链表较长，并将l指向较长的链表，s指向较短的链表
    if (lenA > lenB) {
        l = headA;
        s = headB;
        gap = lenA - lenB; // 计算长度差
    } else {
        l = headB;
        s = headA;
        gap = lenB - lenA; // 计算长度差
    }

    // 尾部对齐，将较长链表指针l向后移动gap个位置，使得两个链表剩余的长度相等
    while (gap--)
        l = l->next;

    // 移动指针l和s，依次比较两个链表中的节点是否相同
    while (l) {
        if (l == s)
            return l; // 如果找到相同的节点，则返回该节点
        l = l->next;
        s = s->next;
    }

    return NULL; // 如果没有找到相同的节点，则返回NULL
}

java写法

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != null) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

}

题目链接

文章链接

142.环形链表II 

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 

判断是否有环 

使用快慢指针法，分别定义 fast 和 slow 指针，从头节点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定在环中相遇 。（fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的）。

寻找环的入口 

从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 

相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2。 即(x + y) * 2 = x + y + n (y + z)     =>    x + y = n (y + z)

环的入口位置为x ，x = n (y + z) - y

将公式化为x = (n - 1) (y + z) + z （n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。）

当 n为1时，

公式化为 x = z 

即定义一个指针index1在相遇节点处，定义一个指针index2在头结点处。让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

 当n大于1时，

fast指针在环形转n圈之后才遇到 slow指针。

index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode *fast = head, *slow = head;  // 使用快慢指针，初始化快慢指针都指向头节点
    while (fast && fast->next) {  // 当快指针和快指针的下一个节点都不为空时，进行循环
        slow = slow->next;  // 慢指针每次向后移动一步
        fast = fast->next->next;  // 快指针每次向后移动两步
        if (slow == fast) {  // 如果快慢指针相遇，说明存在环
            struct ListNode *f = fast, *h = head;  // 创建两个指针，分别从头部和相遇点出发
            while (f != h) 
                f = f->next, h = h->next;  // 两个指针同时向后移动，直到相遇
            return h;  // 返回环的入口节点
        }
    }
    return NULL;  // 如果没有环，则返回NULL
}

java写法

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = 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;
    }
}

 题目链接

 文章链接

 视频链接