题解：AcWing 827 双链表

【题目来源】

【题目描述】

实现一个双链表，双链表初始为空，支持 \(5\) 种操作：

在最左侧插入一个数；
在最右侧插入一个数；
将第 \(k\) 个插入的数删除；
在第 \(k\) 个插入的数左侧插入一个数；
在第 \(k\) 个插入的数右侧插入一个数

现在要对该链表进行 \(M\) 次操作，进行完所有操作后，从左到右输出整个链表。

注意：题目中第 \(k\) 个插入的数并不是指当前链表的第 \(k\) 个数。例如操作过程中一共插入了 \(n\) 个数，则按照插入的时间顺序，这 \(n\) 个数依次为：第 \(1\) 个插入的数，第 \(2\) 个插入的数，…第 \(n\) 个插入的数。

【输入】

第一行包含整数 \(M\)，表示操作次数。

接下来 \(M\) 行，每行包含一个操作命令，操作命令可能为以下几种：

L x，表示在链表的最左端插入数 \(x\)。
R x，表示在链表的最右端插入数 \(x\)。
D k，表示将第 \(k\) 个插入的数删除。
IL k x，表示在第 \(k\) 个插入的数左侧插入一个数。
IR k x，表示在第 \(k\) 个插入的数右侧插入一个数。

【输出】

共一行，将整个链表从左到右输出。

【输入样例】

10
R 7
D 1
L 3
IL 2 10
D 3
IL 2 7
L 8
R 9
IL 4 7
IR 2 2

【输出样例】

8 7 7 3 2 9

【核心思想】

问题分析：需要实现一个支持五种操作的双链表：最左端插入、最右端插入、删除第 \(k\) 个插入的数、在第 \(k\) 个插入的数左侧插入、在第 \(k\) 个插入的数右侧插入。关键观察是：双链表需要同时维护前驱和后继指针，且通过哨兵节点可以统一边界处理，避免头尾特判。
算法选择：
- 数组模拟双链表（静态双链表）：使用数组 e（值）、l（左指针）、r（右指针）和 idx（可用下标）实现
- 双哨兵节点：设置左哨兵 \(0\) 和右哨兵 \(1\)，所有实际节点插入在两个哨兵之间，统一操作逻辑
关键步骤：
- 初始化：r[0] = 1，l[1] = 0，idx = 2（\(0\) 和 \(1\) 为哨兵）
- 在节点 \(k\) 右侧插入 add(k, x)：
  - e[idx] = x，r[idx] = r[k]，l[idx] = k
  - l[r[k]] = idx，r[k] = idx，idx++
- 删除节点 remove(k)：
  - r[l[k]] = r[k]，l[r[k]] = l[k]（左右节点互相指向，跳过 \(k\)）
- 操作映射：
  - L x：最左端插入 \(\rightarrow\) add(0, x)（左哨兵右侧）
  - R x：最右端插入 \(\rightarrow\) add(l[1], x)（右哨兵左侧节点的右侧）
  - D k：删除第 \(k\) 个插入的数 \(\rightarrow\) remove(k + 1)（下标偏移 \(+1\) 因哨兵占用 \(0,1\)）
  - IL k x：左侧插入 \(\rightarrow\) add(l[k + 1], x)
  - IR k x：右侧插入 \(\rightarrow\) add(k + 1, x)
- 遍历输出：从 r[0] 开始沿右指针遍历，直到遇到右哨兵 \(1\)
时间/空间复杂度：
- 时间复杂度：\(O(M)\)，每次操作 \(O(1)\)，遍历输出 \(O(n)\)
- 空间复杂度：\(O(N)\)，预分配数组空间
双哨兵双链表的核心思想：
- 哨兵统一边界：左哨兵 \(0\) 和右哨兵 \(1\) 始终存在，使得"最左端插入"和"最右端插入"都转化为统一的"在某节点右侧插入"操作，消除了头节点和尾节点的特判分支
- 双向指针的 \(O(1)\) 操作：通过同时维护 l 和 r 数组，插入和删除操作只需修改四个指针（新节点的左右、前驱的右、后继的左），无需遍历查找
- 插入序号的偏移映射：由于哨兵占用了下标 \(0\) 和 \(1\)，第 \(k\) 个插入的实际节点下标为 \(k + 1\)，所有操作统一应用该偏移
- 删除的物理保留：数组模拟中删除仅修改指针逻辑断开节点，不回收数组空间，这是静态链表的常见做法，不影响正确性
- 适用于需要双向遍历、两端频繁操作、按固定标识定位节点的场景，是双链表在算法竞赛中的标准实现

【解题思路】

【算法标签】

链表

【代码详解】

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;  // 定义链表最大容量

// 全局变量定义
int m;        // 操作次数
int e[N];     // e[i]存储节点i的值
int l[N];     // l[i]存储节点i的左节点下标
int r[N];     // r[i]存储节点i的右节点下标
int idx;      // 当前可用节点索引

/**
 * 初始化双链表
 * 使用0作为左哨兵节点，1作为右哨兵节点
 */
void init()
{
    // 初始化哨兵节点
    r[0] = 1;    // 左哨兵的右节点是右哨兵
    l[1] = 0;    // 右哨兵的左节点是左哨兵
    idx = 2;     // 已使用0和1两个哨兵节点
}

/**
 * 在节点k的右侧插入值为x的节点
 * @param k 基准节点下标
 * @param x 要插入的值
 */
void add(int k, int x)
{
    e[idx] = x;      // 存储节点值
    r[idx] = r[k];   // 新节点的右指针指向k的右节点
    l[idx] = k;      // 新节点的左指针指向k

    l[r[k]] = idx;   // k的原右节点的左指针指向新节点
    r[k] = idx;      // k的右指针指向新节点

    idx++;           // 分配下一个可用节点
}

/**
 * 删除指定节点
 * @param k 要删除的节点下标
 */
void remove(int k)
{
    r[l[k]] = r[k];  // 左节点的右指针指向右节点
    l[r[k]] = l[k];  // 右节点的左指针指向左节点
}

int main()
{
    cin >> m;  // 输入操作次数

    init();    // 初始化双链表

    while (m--)
    {
        string s;  // 操作类型
        int k, x;  // 操作参数

        cin >> s;

        if (s == "L")
        {
            // 在链表最左端插入
            cin >> x;
            add(0, x);  // 在左哨兵右侧插入
        }
        else if (s == "R")
        {
            // 在链表最右端插入
            cin >> x;
            add(l[1], x);  // 在右哨兵的左侧节点右侧插入
        }
        else if (s == "D")
        {
            // 删除第k个插入的节点
            cin >> k;
            remove(k + 1);  // 调整索引（哨兵节点占用了0和1）
        }
        else if (s == "IL")
        {
            // 在第k个插入的节点左侧插入
            cin >> k >> x;
            add(l[k + 1], x);  // 相当于在k节点的前驱节点右侧插入
        }
        else
        {
            // 在第k个插入的节点右侧插入
            cin >> k >> x;
            add(k + 1, x);  // 直接插入到k节点右侧
        }
    }

    // 遍历输出链表（从左哨兵到右哨兵）
    for (int i = r[0]; i != 1; i = r[i])
    {
        cout << e[i] << " ";
    }
    cout << endl;

    return 0;
}

【运行结果】

10
R 7
D 1
L 3
IL 2 10
D 3
IL 2 7
L 8
R 9
IL 4 7
IR 2 2
8 7 7 3 2 9

posted @ 2026-07-02 22:47 团爸讲算法阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

题解：AcWing 827 双链表

链表

公告