Linked List on Hang Zhang

Reverse Linked List II

Wed, 21 May 2025 00:00:00 +0000

92. 反转链表II

分析

创建一个虚拟头节点 dummy，它的 next 指向 head，简化边界情况处理（如 left = 1）
用指针 p 找到 left 节点的前一个节点
从 p->next 开始反转区间 [left, right] 的节点，采用头插法实现
反转完成后，将前后链表重新接好

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* reverseBetween(ListNode* head, int left, int right)
    {
      ListNode* dummy = new ListNode(-1); // 创建虚拟头节点，简化边界处理
      dummy->next = head;

      ListNode* p = dummy;
      // 将 p 移动到 left 前一个节点的位置
      for (int i = 0; i < left - 1; ++ i)
        p = p->next;

      // 初始化要反转的部分的起始节点
      ListNode *prev = p->next, *cur = prev->next;

      // 头插法反转 [left, right] 区间
      for (int i = 0; i < right - left; ++ i)
      {
        ListNode *next = cur->next; // 暂存下一个节点
        cur->next = prev;           // 当前节点指向前一个节点
        prev = cur, cur = next;     // 向前推进指针
      }

      // 拼接反转后的子链表与剩余链表
      ListNode *q = p->next; // 反转前的 left 节点，反转后变成尾部
      p->next = prev;        // p 指向反转后的头部
      q->next = cur;         // 原 left 节点指向反转后剩余的部分

      return dummy->next;    // 返回新链表头节点
    }
};

Reorder List

Fri, 04 Apr 2025 00:00:00 +0000

143. 重排链表

分析

第一步：找到链表的中点
- 遍历链表长度，再通过 (len + 1) / 2 找到中间节点位置
第二步：反转链表后半段
- 从中点开始，原地反转链表后半段
第三步：合并两段链表
- 将前半段和后半段反转后的链表进行交叉合并
- 注意尾指针的处理，避免无限循环

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void reorderList(ListNode* head)
    {
        if (!head) return;

        // 1. 统计链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 2. 找到链表中点
        ListNode* mid = head;
        for (int i = 0; i < (len + 1) / 2 - 1; ++i)
            mid = mid->next;

        // 3. 反转链表后半部分
        ListNode *a = mid, *b = mid->next;
        for (int i = 0; i < len / 2; ++i)
        {
            ListNode* c = b->next;
            b->next = a;
            a = b;
            b = c;
        }

        // 4. 合并两段链表
        ListNode *p = head, *q = a;
        for (int i = 0; i < len / 2; ++i)
        {
            ListNode* o = q->next;
            q->next = p->next;
            p->next = q;

            if (len % 2 == 0 && i == len / 2 - 1)
                q->next = nullptr;

            q = o;
            p = p->next->next;
        }

        if (len % 2 == 1)
            p->next = nullptr;
    }
};

Insertion Sort List

Sun, 19 Jan 2025 00:00:00 +0000

147. 对链表进行插入排序

分析

使用一个虚拟头节点 dummy 来方便构建有序链表
遍历原链表：
- 对于当前节点 p，从虚拟头节点 dummy 开始查找它应插入的位置
- 插入后调整指针以确保链表仍然连接正确
继续处理下一节点，直到原链表遍历结束
返回排序后的链表

时间复杂度

外层遍历链表，每个节点插入有序链表的过程中需查找插入位置。
最坏情况下（链表反序），插入每个节点需要遍历整个有序链表，时间复杂度为 O(n^2)，其中 n 是链表的长度

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* insertionSortList(ListNode* head)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        ListNode* p = head;

        // 遍历原链表
        while (p)
        {
            // 找到插入点：从 dummy 开始找到第一个大于当前节点值的位置
            ListNode* cur = dummy;
            while (cur->next && cur->next->val <= p->val)
                cur = cur->next;

            // 插入当前节点到有序链表
            ListNode* next = p->next;  // 保存下一个节点
            p->next = cur->next;      // 当前节点指向插入位置后的节点
            cur->next = p;            // 插入当前节点到有序链表
            p = next;                 // 继续处理下一个节点
        }

        // 返回排序后的链表
        return dummy->next;
    }
};

Partition List

Sun, 19 Jan 2025 00:00:00 +0000

86. 分隔链表

分析

使用两个虚拟头节点 small_head 和 big_head 分别构建两条子链表：

遍历原链表，对于每个节点：
- 如果值小于 x，将该节点添加到以 small_head 为头的链表
- 如果值大于或等于 x，将该节点添加到以 big_head 为头的链表
遍历结束后，将小链表的尾部连接到大链表的头部
返回合并后的链表（从 small_head->next 开始）

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* partition(ListNode* head, int x)
    {
        // 初始化两个虚拟头节点和尾指针
        auto small_head = new ListNode(-1), big_head = new ListNode(-1);
        auto small_tail = small_head, big_tail = big_head;

        // 遍历链表，分隔节点
        for (auto p = head; p; p = p->next)
        {
            if (p->val < x)
                small_tail = small_tail->next = p; // 添加到小链表
            else
                big_tail = big_tail->next = p;    // 添加到大链表
        }

        // 合并两部分链表
        small_tail->next = big_head->next;
        big_tail->next = NULL; // 确保大链表尾部没有残留节点

        return small_head->next; // 返回分隔后的链表
    }
};

Flatten Binary Tree to Linked List

Tue, 31 Dec 2024 00:00:00 +0000

114. 二叉树展开为链表

分析

遍历二叉树的每个节点
如果当前节点存在左子树：
- 将左子树的最右节点找到，并连接到当前节点的右子树上
- 然后将当前节点的右子树替换为它的左子树，同时将左子树置为 null
移动到当前节点的右子节点，继续上述操作，直至遍历完所有节点

时间复杂度

时间复杂度 O(n)，每个节点遍历一次，且寻找左子树最右节点的过程也是线性的

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    void flatten(TreeNode* root)
    {
        while (root) // 遍历每个节点
        {
            TreeNode* p = root->left; // 获取当前节点的左子树
            if (p) // 如果存在左子树
            {
                // 找到左子树的最右节点
                while (p->right)
                    p = p->right;

                // 将左子树的最右节点与右子树连接
                p->right = root->right;

                // 将当前节点的右子树替换为左子树
                root->right = root->left;

                // 将左子树置为 null
                root->left = nullptr;
            }
            // 移动到右子节点
            root = root->right;
        }
    }
};

Odd Even Linked List

Sat, 28 Dec 2024 00:00:00 +0000

328. 奇偶链表

分析

特例处理：
- 如果链表为空，或只有一个节点，则无需操作，直接返回原链表
分离奇偶链表：
- 定义两个链表头指针：
  - odd_head：奇数节点的头指针，初始为 head
  - even_head：偶数节点的头指针，初始为 head->next
- 遍历链表：
  - 用 odd_tail 和 even_tail 分别维护奇数链表和偶数链表的尾节点
  - 根据节点的索引位置，交替更新奇数链表和偶数链表的尾节点
拼接奇偶链表：
- 将奇数链表的尾节点连接到偶数链表的头节点
- 将偶数链表的尾节点指向 nullptr
返回结果：
- 返回奇数链表的头节点 odd_head

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* oddEvenList(ListNode* head)
    {
        // 特例处理：链表为空或只有一个节点
        if (!head || !head->next)
            return head;

        // 初始化奇数链表和偶数链表的头尾指针
        ListNode *odd_head = head, *odd_tail = odd_head;
        ListNode *even_head = head->next, *even_tail = even_head;

        // 遍历链表，交替处理奇数节点和偶数节点
        for (ListNode* p = head->next->next; p;)
        {
            // 处理奇数节点
            odd_tail = odd_tail->next = p;
            p = p->next;

            // 处理偶数节点
            if (p)
            {
                even_tail = even_tail->next = p;
                p = p->next;
            }
        }

        // 拼接奇数链表和偶数链表
        odd_tail->next = even_head;
        even_tail->next = nullptr;

        return odd_head;
    }
};

Sort List

Sun, 01 Dec 2024 00:00:00 +0000

148. 排序链表

分析

计算链表长度
- 遍历链表，统计节点数量 n，以确定归并的步长范围
自底向上归并排序
- 按步长 i 从小到大逐步归并，初始步长为 1，逐渐乘以 2，直到覆盖整个链表
- 每次归并时，将链表分成两部分，每部分包含 i 个节点，然后对这两部分进行归并
- 最后将归并的结果重新连接到链表中
归并两个子链表
- 使用两个指针分别指向两个子链表的头部，逐一比较节点的值，将较小值的节点加入到排序后的链表中，直到处理完两部分中的所有节点
更新链表
- 经过多轮归并后，最终的链表即为排序后的链表

时间复杂度

每轮归并的时间复杂度为 O(n)，需要进行 log(n) 轮归并，因此总复杂度为 O(nlogn)

空间复杂度

采用自底向上归并，不需要额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* sortList(ListNode* head)
    {
        // 第 1 步：计算链表长度
        int n = 0;
        for (ListNode* p = head; p; p = p->next)
            ++n;

        // 第 2 步：归并排序
        for (int i = 1; i < n; i *= 2)
        {
            ListNode* dummy = new ListNode(-1); // 虚拟头节点
            ListNode* cur = dummy;

            for (int j = 1; j <= n; j += i * 2)
            {
                // 划分两段链表
                ListNode *p = head, *q = p;
                for (int k = 0; k < i && q; ++k)
                    q = q->next; // 第二段起点

                ListNode* o = q;
                for (int k = 0; k < i && o; ++k)
                    o = o->next; // 下一部分的起点

                // 归并两段链表
                int l = 0, r = 0;
                while (l < i && r < i && p && q)
                {
                    if (p->val <= q->val)
                    {
                        cur->next = p;
                        p = p->next;
                        ++l;
                    }
                    else
                    {
                        cur->next = q;
                        q = q->next;
                        ++r;
                    }
                    cur = cur->next;
                }

                // 剩余部分处理
                while (l < i && p)
                {
                    cur = cur->next = p;
                    p = p->next;
                    ++l;
                }

                while (r < i && q)
                {
                    cur = cur->next = q;
                    q = q->next;
                    ++r;
                }

                // 更新链表头
                head = o;
            }
            cur->next = nullptr;
            head = dummy->next; // 更新链表头为新的排序结果
        }

        return head;
    }
};

Add Two Numbers

Sat, 30 Nov 2024 00:00:00 +0000

2. 两数相加

分析

初始化
- 使用一个虚拟头节点 dummy，方便操作结果链表
- 用指针 cur 指向结果链表的当前尾部
- 定义一个变量 sum 用于存储当前位的加和（包括进位）
逐位相加
- 遍历链表 l1 和 l2，对每一位的值进行相加，同时加上进位 sum
- 取个位数字作为当前位的值，新建节点添加到结果链表中
- 更新 sum 为十位上的进位。
处理进位
- 当 l1 和 l2 遍历完后，如果还有进位 sum > 0，需要额外创建一个节点存储进位

时间复杂度

时间复杂度 O(max(n, m))，n 和 m 分别为链表 l1 和 l2 的长度，需要遍历两链表的所有节点

空间复杂度

空间复杂度为 O(max(n, m))

C++代码

class Solution
{
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
    {
        int sum = 0; // 用于存储每个位的和以及进位
        ListNode* dummy = new ListNode(-1); // 虚拟头节点
        ListNode* cur = dummy; // 指向结果链表的当前尾部

        // 遍历链表 l1 和 l2
        while (l1 || l2 || sum)
        {
            // 如果 l1 或 l2 不为空，加上它们当前位的值
            if (l1)
            {
                sum += l1->val;
                l1 = l1->next; // 移动到下一位
            }
            if (l2)
            {
                sum += l2->val;
                l2 = l2->next; // 移动到下一位
            }

            // 创建新节点存储当前位的值，并连接到结果链表
            cur = cur->next = new ListNode(sum % 10);

            // 更新进位
            sum /= 10;
        }

        // 返回结果链表
        return dummy->next;
    }
};

Copy List with Random Pointer

Sat, 30 Nov 2024 00:00:00 +0000

138. 随机链表的复制

分析

在原链表中插入新节点
- 遍历原链表，对于每个节点 p，创建一个新节点 q
- 将新节点插入到原节点 p 和 p->next 之间，形成交错链表结构：原节点 -> 新节点 -> 原节点
复制 random 指针
- 再次遍历交错链表，对于每个原节点 p，将 p->next->random 设置为 p->random->next，即新节点的 random 指向对应的新节点
拆分链表
- 遍历交错链表，将新节点从中分离出来，形成深拷贝链表，同时还原原链表的结构

时间复杂

遍历链表三次，分别处理插入节点、复制 random 指针、拆分链表，时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    Node* copyRandomList(Node* head)
    {
        // 第 1 步：在原链表中插入新节点
        for (Node* p = head; p; p = p->next->next)
        {
            Node* q = new Node(p->val); // 创建新节点
            q->next = p->next;         // 插入新节点到原节点之后
            p->next = q;
        }

        // 第 2 步：复制 random 指针
        for (Node* p = head; p; p = p->next->next)
        {
            if (p->random)
                p->next->random = p->random->next; // 设置新节点的 random
        }

        // 第 3 步：拆分链表
        Node* dummy = new Node(-1); // 虚拟头节点
        Node* cur = dummy;
        for (Node* p = head; p; p = p->next)
        {
            Node* q = p->next;       // 取出新节点
            cur = cur->next = q;     // 将新节点连接到深拷贝链表
            p->next = q->next;       // 恢复原链表结构
        }

        return dummy->next;
    }
};

linkedListCycle

Fri, 29 Nov 2024 00:00:00 +0000

141. 环形链表

分析

初始化指针
- 如果链表为空或只有一个节点，则无法形成环，直接返回 false
- 设置两个指针 slow 和 fast，初始时都指向链表的头节点 head
移动指针
- 慢指针 slow 每次移动一步
- 快指针 fast 每次移动两步
- 每次移动后，检查 slow 和 fast 是否相等。如果相等，说明链表中存在环
终止条件
- 如果 fast 为 nullptr，说明链表没有环，直接返回 false

时间复杂度

慢指针最多遍历链表一次，快指针最多遍历链表两次，因此时间复杂度为 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool hasCycle(ListNode *head)
    {
        // 链表为空或只有一个节点，无法形成环
        if (!head || !head->next)
            return false;

        ListNode *slow = head, *fast = head;

        while (fast) // 快指针未到达链表末尾
        {
            slow = slow->next;           // 慢指针走一步
            fast = fast->next;           // 快指针走一步
            if (fast)
                fast = fast->next;       // 快指针再走一步

            if (slow == fast)            // 快慢指针相遇，存在环
                return true;
        }
        return false; // 快指针到达链表末尾，无环
    }
};

linkedListCycleII

Fri, 29 Nov 2024 00:00:00 +0000

142. 环形链表II

分析

判断链表是否有环
- 设置两个指针 slow 和 fast，初始都指向链表头节点 head
- 快指针每次移动两步，慢指针每次移动一步
- 如果快指针追上慢指针，说明链表中有环；否则，如果快指针或其下一节点为空，则链表无环
找到环的起始节点
- 当快慢指针相遇时，将慢指针重置为链表头节点 head
- 快指针保持在相遇位置
- 两个指针每次都向前移动一步，当两者再次相遇时，相遇点即为环的起始节点

数学推导

假设：

链表头到环入口节点的距离为 a
环入口到相遇点的距离为 b
相遇点到环入口的距离为 c

快指针比慢指针速度快一倍，因此：2(a + b) = a + b + n(b + c)（ n 为快指针在环中绕的圈数），化简得：a = c + (n - 1)(b + c)

这表明：

从链表头节点到环入口的距离 a 等于从相遇点沿环走回入口的距离 c
因此，当两个指针一个从链表头开始，一个从相遇点开始，每次移动一步，最终会在环的起始节点相遇

时间复杂度

快慢指针遍历链表一次即可确定是否有环，以及找到环的起始节点，时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        // 链表为空或只有一个节点，不可能有环
        if (!head || !head->next)
            return nullptr;

        ListNode *slow = head, *fast = head;

        // 判断链表是否有环
        while (fast)
        {
            slow = slow->next;          // 慢指针走一步
            fast = fast->next;          // 快指针走一步
            if (fast)
                fast = fast->next;      // 快指针再走一步

            if (slow == fast)           // 快慢指针相遇
            {
                // 找到环的起始节点
                slow = head;            // 慢指针回到链表头
                while (slow != fast)    // 两指针相遇即为环入口
                {
                    slow = slow->next;
                    fast = fast->next;
                }
                return fast;
            }
        }

        return nullptr; // 无环
    }
};

palindromeLinkedList

Fri, 29 Nov 2024 00:00:00 +0000

234. 回文链表

分析

计算链表长度
- 遍历链表一次，统计节点总数 len。用于确定需要存入栈的节点数量
存储前半部分元素到栈中
- 再次遍历链表，将前半部分的节点值压入栈中。如果链表长度为奇数，则跳过中间节点（因为中间节点不影响回文判断）
比较后半部分的值
- 从链表中间位置开始继续遍历链表，每遇到一个节点，就弹出栈顶的元素，与当前节点值比较。如果有任意不相等的情况，说明链表不是回文链表
判断结果
- 遍历完后，若所有值都匹配，则链表是回文的，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    bool isPalindrome(ListNode* head)
    {
        // 求链表长度
        int len = 0;
        for (ListNode* p = head; p; p = p->next)
            ++len;

        // 用栈存储前半部分节点值
        ListNode* p = head;
        std::stack<int> stk;
        for (int i = 0; i < len / 2; ++i)
        {
            stk.push(p->val);
            p = p->next;
        }

        // 如果链表长度为奇数，跳过中间节点
        if (len % 2 == 1)
            p = p->next;

        // 比较后半部分节点值与栈中元素
        while (p)
        {
            if (stk.top() != p->val)
                return false;
            stk.pop();
            p = p->next;
        }

        return true;
    }
};

Reverse Linked List

Fri, 29 Nov 2024 00:00:00 +0000

206. 反转链表

分析

初始化指针
- 定义一个指针 prev，初始值为 nullptr，用于指向反转后链表的头节点
- 定义一个指针 cur，初始指向链表的头节点 head，用于遍历链表
遍历链表
- 在遍历的每一步，保存当前节点的下一节点 next
- 调整当前节点 cur 的 next 指针，使其指向 prev，实现反转
- 将 prev 更新为当前节点 cur，将 cur 更新为 next
终止条件
- 当 cur 遍历到链表末尾（即为 nullptr ）时，链表已经完全反转，此时 prev 指针指向反转后的链表头节点

时间复杂度

时间复杂度 O(n)，其中 n 为链表的长度。每个节点访问一次

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode* reverseList(ListNode* head)
    {
        ListNode* prev = nullptr;  // 初始化反转链表的头节点为 nullptr
        ListNode* cur = head;      // 从链表头节点开始遍历
        while (cur)                // 遍历整个链表
        {
            ListNode* next = cur->next; // 保存当前节点的下一节点
            cur->next = prev;          // 将当前节点的 next 指向反转链表的头
            prev = cur;                // 更新 prev 为当前节点
            cur = next;                // 继续遍历下一个节点
        }
        return prev;                   // 返回反转后的链表头节点
    }
};

// 递归
class Solution
{
public:
    ListNode* reverseList(ListNode* head)
    {
        // 递归终止条件：空节点或只有一个节点时直接返回
        if (!head || !head->next) return head;

        // 递归反转后面的链表，tail 是反转后的新头节点
        ListNode* tail = reverseList(head->next);

        // 将当前节点放到反转链表的尾部
        head->next->next = head;
        head->next = nullptr;

        return tail;  // 返回新的头节点
    }
};

intersectionOfTwoLinkedLists

Thu, 28 Nov 2024 00:00:00 +0000

160. 相交链表

分析

初始化指针
- 定义两个指针 p 和 q，分别指向链表 headA 和 headB 的头节点
遍历链表
- 让两个指针同时遍历各自的链表，当某个指针到达链表尾部时，切换到另一个链表的头节点继续遍历
终止条件
- 如果链表相交，p 和 q 会在相交节点相遇，此时返回相交节点
- 如果链表不相交，两个指针会同时变为 null，退出循环并返回 null
关键点
- 当一个指针遍历完自己的链表后，切换到另一个链表，从而保证两个指针在第二次遍历时长度相同
- 这样，当两链表有相交节点时，两个指针在第二次遍历中必定会在相交节点处相遇

时间复杂度

指针最多遍历两个链表一次，两个链表的长度分别为 m 和 n，总时间复杂度 O(m + n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
    {
        ListNode *p = headA, *q = headB; // 初始化两个指针 p 和 q
        while (p != q)                  // 当 p 和 q 不相等时继续循环
        {
            p = p ? p->next : headB;    // 如果 p 非空，移动到下一个节点，否则切换到 headB
            q = q ? q->next : headA;    // 如果 q 非空，移动到下一个节点，否则切换到 headA
        }
        return p;                       // 返回相交节点或 null
    }
};

LRUCache

Sun, 24 Nov 2024 00:00:00 +0000

31. LRUCache

分析

LRU（Least Recently Used）是一种缓存替换策略，淘汰最久未被使用的数据，以保证缓存内存的有效利用率

核心数据结构：
- 双向链表：维护缓存访问顺序，最新使用的数据放在链表头，最久未使用的数据放在链表尾。双向链表的插入和删除操作可以在 O(1) 时间内完成，适用于缓存频繁更新的场景
- 哈希表：通过关键字快速定位链表中的节点
get(key)：
- 若 key 存在，将对应节点移动到链表头，并返回其值
- 若 key 不存在，返回 -1
put(key, value)：
- 若 key 已存在，更新其值并移动到链表头
- 若 key 不存在：
- 如果缓存已满，删除链表尾的节点（最久未使用）
- 将新节点插入到链表头

时间复杂度

get(key)：O(1)
- 哈希表查找节点是 O(1) ，双向链表操作也是 O(1)
put(key, value)：O(1)
- 哈希表插入和删除是 O(1) ，双向链表操作也是 O(1)

空间复杂度

哈希表和双向链表的空间复杂度均为 O(n) ，其中 n 是缓存容量

C++代码

class LRUCache {
public:
    // 定义双向链表节点
    struct Node
    {
      Node(int key, int value)
        : m_key(key), m_value(value)
        , prev(nullptr), next(nullptr)
      {}

      int m_key, m_value;
      Node *prev, *next;
    };

    int n;                                 // 缓存容量
    Node *head, *tail;                     // 双链表的虚拟头节点
    std::unordered_map<int, Node*> hash;   // 哈希表，快速查找节点

    // 初始化 LRU 缓存
    LRUCache(int capacity)
    {
      n = capacity;
      head = new Node(-1, -1);             // 创建虚拟头节点
      tail = new Node(-1, -1);             // 创建虚拟尾节点
      head->next = tail;                   // 初始化双向链表
      tail->prev = head;
    }

    // 从链表中删除指定节点
    void remove(Node* cur)
    {
      cur->next->prev = cur->prev;
      cur->prev->next = cur->next;
    }

    // 在链表头部插入指定节点
    void insert(Node* cur)
    {
      cur->next = head->next;
      cur->prev = head;
      head->next->prev = cur;
      head->next = cur;
    }

    // 获取节点的值
    int get(int key)
    {
      if (!hash.count(key))                 // 节点不存在
        return -1;
      Node* cur = hash[key];                // 定位节点
      remove(cur);                          // 更新节点在链表中的位置
      insert(cur);
      return cur->m_value;
    }

    // 插入或更新节点
    void put(int key, int value)
    {
      if (hash.count(key))                  // 节点已存在
      {
        Node* cur = hash[key];
        cur->m_value = value;               // 更新节点值
        remove(cur);                        // 更新节点位置
        insert(cur);
      }
      else                                  // 节点不存在
      {
        if (hash.size() == n)               // 缓存已满
        {
          Node* cur = tail->prev;           // 取出尾节点
          remove(cur);                      // 从链表中移除
          hash.erase(cur->m_key);           // 从哈希表中删除
        }
        Node* cur = new Node(key, value);   // 创建新节点
        insert(cur);                        // 插入链表头
        hash[key] = cur;                    // 添加到哈希表
      }
    }
};

Reverse Nodes in k-Group

Tue, 26 Mar 2024 00:00:00 +0000

25. Reverse Nodes in k-Group

分析

引入虚拟头节点
- 创建一个虚拟头节点 dummy，使其 next 指向链表的头节点，以便统一处理头节点的翻转
遍历链表检查是否需要翻转
- 使用指针 cur 标记当前分组的前驱节点
- 检查 cur 后是否至少还有 k 个节点。如果节点数不足 k，直接退出循环
翻转当前分组的 k 个节点
- 记录当前分组的起点 a 和翻转后的起点 b
- 按照链表翻转的规则，通过调整指针完成当前分组内的节点翻转，循环 k-1 次
连接翻转后的链表
- 让当前分组的前驱节点 cur->next 指向翻转后的新头节点 a
- 让当前分组的尾节点连接到下一分组的起始节点 b
- 更新 cur 为当前分组的尾节点

时间复杂度

每个节点最多被访问两次（检查和翻转），时间复杂度 O(n)

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* reverseKGroup(ListNode* head, int k)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;

        ListNode* cur = dummy;

        while (true)
        {
            // 检查是否有足够的节点进行翻转
            ListNode* check = cur;
            for (int i = 0; i < k && check; ++i)
                check = check->next;
            if (!check)
                break;

            // 翻转当前分组的 k 个节点
            ListNode *a = cur->next, *b = cur->next->next;
            for (int i = 0; i < k - 1; ++i)
            {
                ListNode* c = b->next; // 暂存下一节点
                b->next = a;          // 翻转当前节点
                a = b;                // 同时后移
                b = c;
            }

            // 连接翻转后的链表
            ListNode* c = cur->next;
            cur->next = a;   // 当前分组的前驱节点指向翻转后的新头节点
            c->next = b;     // 当前分组的尾节点连接到下一分组的起始节点
            cur = c;         //  更新 cur 为当前分组的尾节点
        }

        // 返回结果链表
        return dummy->next;
    }
};

Swap Nodes in Pairs

Tue, 26 Mar 2024 00:00:00 +0000

24. Swap Nodes in Pairs

分析

创建虚拟头节点
- 为了方便处理头节点的交换，创建一个虚拟头节点 dummy，使其 next 指向链表的头节点
遍历链表并交换节点
- 使用指针 cur 指向当前正在处理的一对节点的前驱节点。
- 检查当前节点 cur->next 和 cur->next->next 是否存在，只有在有足够节点时才进行交换
- 定义两个指针 p 和 q 分别指向待交换的两个节点：
  - 交换后，cur->next 指向第二个节点 q
  - 第一个节点 p->next 指向第三个节点
  - 第二个节点 q->next 指向第一个节点
- 将指针 cur 移动到已交换节点对的末尾，继续处理下一对

时间复杂度

时间复杂度 O(n)，遍历链表一次，其中 n 是链表的长度

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* swapPairs(ListNode* head)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;

        // 遍历链表并交换节点
        for (ListNode* cur = dummy; cur->next && cur->next->next; )
        {
            ListNode *p = cur->next, *q = p->next; // 定义待交换的两个节点
            cur->next = q;                         // 前驱节点指向第二个节点
            p->next = q->next;                     // 第一个节点指向第三个节点
            q->next = p;                           // 第二个节点指向第一个节点
            cur = p;                               // 移动到下一组的前驱节点
        }

        // 返回结果链表
        return dummy->next;
    }
};

Merge k Sorted Lists

Mon, 25 Mar 2024 00:00:00 +0000

23. 合并K个升序链表

分析

使用优先队列
- 创建一个优先队列 heap，用于存储链表节点
- 队列中的元素按节点值从小到大排序（小根堆）
- 使用一个自定义比较器 cmp 来实现小根堆的逻辑
初始化优先队列
- 将所有链表的头节点（如果非空）加入优先队列
归并链表
- 每次从优先队列中取出值最小的节点 temp，将其加入新链表
- 如果 temp 节点还有下一个节点，则将其 next 节点加入优先队列
- 重复以上步骤，直到队列为空

时间复杂度

优先队列的插入和删除操作的时间复杂度为 O(logk)，其中 k 是链表的数量
每个节点都会被插入和删除一次，因此总时间复杂度为 O(nlogk)，其中 n 是链表中所有节点的总数

空间复杂度

优先队列最多同时存储 k 个节点，因此空间复杂度为 O(k)

C++代码

class Solution
{
public:
    ListNode* mergeKLists(vector<ListNode*>& lists)
    {
        // 自定义比较器，用于优先队列排序
        struct cmp
        {
            bool operator()(ListNode* a, ListNode* b)
            {
                return a->val > b->val; // 小根堆
            }
        };

        // 定义优先队列（小根堆）
        std::priority_queue<ListNode*, std::vector<ListNode*>, cmp> heap;

        // 初始化优先队列，将每个链表的头节点加入堆中
        for (ListNode* li : lists)
            if (li)
                heap.push(li);

        // 定义虚拟头节点，便于操作新链表
        ListNode* dummy = new ListNode(-1);
        ListNode* cur = dummy;

        // 从优先队列中逐步取出最小值节点，并更新链表
        while (!heap.empty())
        {
            ListNode* temp = heap.top(); // 获取当前最小值节点
            heap.pop();                  // 将其从堆中移除
            cur = cur->next = temp;      // 将其加入新链表
            if (temp->next)              // 如果有后续节点，将后续节点加入堆中
            {
                temp = temp->next;
                heap.push(temp);
            }
        }

        // 返回合并后的链表
        return dummy->next;
    }
};

Merge Two Sorted Lists

Fri, 22 Mar 2024 00:00:00 +0000

21. Merge Two Sorted Lists

分析

创建虚拟头节点
- 创建一个虚拟头节点 dummy，用于方便拼接新链表，同时维护一个指针 cur 指向结果链表的当前末尾
比较两个链表节点值
- 遍历 list1 和 list2，每次比较当前节点值，将较小值的节点接到 cur 的后面，并将对应链表的指针后移
拼接剩余节点
- 如果某个链表还有剩余节点（未遍历完），直接将其接到结果链表末尾
返回结果链表
- 返回虚拟头节点的下一个节点 dummy->next，即为合并后的升序链表

时间复杂度

遍历两个链表，最多比较 n + m 次，其中 n 和 m 分别为两个链表的长度，时间复杂度 O(m + n)

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
    {
        // 创建虚拟头节点，简化操作
        ListNode *dummy = new ListNode();
        ListNode* cur = dummy;

        // 归并两个链表
        while (list1 && list2)
        {
            if (list1->val <= list2->val) // list1节点值较小
            {
                cur = cur->next = list1;  // 接入结果链表
                list1 = list1->next;      // list1指针后移
            }
            else                          // list2节点值较小
            {
                cur = cur->next = list2;  // 接入结果链表
                list2 = list2->next;      // list2指针后移
            }
        }

        // 拼接剩余的链表
        if (list1) cur->next = list1;
        if (list2) cur->next = list2;

        // 返回结果链表
        return dummy->next;
    }
};

Remove Nth Node From End of List

Thu, 21 Mar 2024 00:00:00 +0000

19. Remove Nth Node From End of List

分析

创建虚拟头节点
- 为了方便处理边界情况（如删除头节点），创建一个虚拟头节点 dummy，其 next 指向链表头部
计算链表长度
- 遍历链表，用变量 len 记录链表的总长度
定位目标节点的前驱节点
- 倒数第 n 个节点的前驱节点是正数第 len - n 个节点
- 从虚拟头节点开始，移动 len - n 步到目标位置
删除目标节点
- 通过修改前驱节点的 next 指针，跳过目标节点

时间复杂度

需要遍历链表两次，计算链表长度和定位目标节点位置，时间复杂度 O(L)， L 是链表长度

空间复杂度

空间复杂度 O(1)

C++代码

class Solution
{
public:
    ListNode* removeNthFromEnd(ListNode* head, int n)
    {
        // 创建虚拟头节点
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;

        // 计算链表长度
        int len = 0;
        for (ListNode* p = dummy; p; p = p->next)
            ++len;

        // 定位到要删除节点的前驱节点
        ListNode* p = dummy;
        for (int i = 0; i < len - n - 1; ++i)
            p = p->next;

        // 删除目标节点
        p->next = p->next->next;

        // 返回结果链表
        return dummy->next;
    }
};