143.重排链表-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40844444/article/details/146466922

143.重排链表

题目叙述

给定一个单链表 L 的头节点 head ，单链表 L 表示为：
$L_0 → L_1 → … → L_{n - 1} → L_n$
请将其重新排列后变为：
$L_0 → L_n → L_1 → L_{n - 1} → L_2 → L_{n - 2} → …$
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：
输入：head = [1,2,3,4]
输出：[1,4,2,3]

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

模式识别

本题可以通过将链表问题拆分成多个子问题来解决。主要思路是先找到链表的中间节点，将链表分为前后两部分；然后反转后半部分链表；最后将前半部分链表和反转后的后半部分链表进行合并。这种将复杂问题分解为多个简单子问题的模式在链表操作中较为常见。

考点分析

链表操作：需要熟练掌握链表节点的遍历、查找、反转和合并等基本操作。
双指针法：使用快慢指针来找到链表的中间节点。
逻辑思维：需要清晰地规划出解题步骤，将各个子问题有序地组合起来。

所有解法

使用数组存储节点：遍历链表，将所有节点存储在一个数组中。然后根据数组下标重新连接节点，实现重排。时间复杂度为 $O (n)$ ，空间复杂度为 $O (n)$ 。
原地重排（最优解法）：
- 找到链表的中间节点。
- 反转链表的后半部分。
- 合并前半部分链表和反转后的后半部分链表。
  时间复杂度为 $O (n)$ ，空间复杂度为 $O (1)$ 。

C 语言最优解法代码

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
struct ListNode {
    int val;  // 节点存储的值
    struct ListNode *next;  // 指向下一个节点的指针
};

// 找到链表的中间节点
struct ListNode* findMiddle(struct ListNode* head) {
    struct ListNode* slow = head;  // 慢指针，初始指向头节点
    struct ListNode* fast = head;  // 快指针，初始指向头节点
    // 快指针每次移动两步，慢指针每次移动一步
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;  // 返回中间节点
}

// 反转链表
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;  // 前一个节点，初始为 NULL
    struct ListNode* curr = head;  // 当前节点，初始指向头节点
    struct ListNode* next = NULL;  // 下一个节点
    while (curr != NULL) {
        next = curr->next;  // 保存当前节点的下一个节点
        curr->next = prev;  // 当前节点指向前一个节点
        prev = curr;  // 前一个节点移动到当前节点
        curr = next;  // 当前节点移动到下一个节点
    }
    return prev;  // 返回反转后的头节点
}

// 合并两个链表
void mergeLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* l1_temp;
    struct ListNode* l2_temp;
    while (l1 != NULL && l2 != NULL) {
        l1_temp = l1->next;  // 保存 l1 的下一个节点
        l2_temp = l2->next;  // 保存 l2 的下一个节点

        l1->next = l2;  // l1 指向 l2
        l2->next = l1_temp;  // l2 指向 l1 的下一个节点

        l1 = l1_temp;  // l1 移动到保存的下一个节点
        l2 = l2_temp;  // l2 移动到保存的下一个节点
    }
}

// 重排链表函数
void reorderList(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    // 找到链表的中间节点
    struct ListNode* mid = findMiddle(head);
    // 后半部分链表的头节点
    struct ListNode* l2 = mid->next;
    mid->next = NULL;  // 断开前半部分和后半部分的连接
    // 反转后半部分链表
    l2 = reverseList(l2);
    // 合并前半部分和反转后的后半部分链表
    mergeLists(head, l2);
}