單鏈表

採用動態連結串列的方式：

struct Node
{
    int val;
    Node *next;
}
new Node();	// 非常慢

會非常慢，在演算法競賽中常常採用陣列模擬連結串列，也叫靜態連結串列

head：表示頭節點下標

e[N]: 每個節點的值

ne[N]：每個節點的下一個節點編號(下標)

例如下面的連結串列：

初始化

// head：表示頭節點的下標
// e[i]: 表示第i個節點的值
// ne[i]: 表示第i個節點的下一個節點的編號
// idx：當前用到的節點編號
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head = -1;	// 表示連結串列為空
    idx = 0;	// 從0開始分配
}
 

將值為 x 的新節點插入頭節點

1. 先將插入節點指向頭節點（下標）
2. 頭節點指向新插入的節點（下標）

首先要儲存新節點，插入完成後，節點編號++

// 將值為x的節點插入到頭節點的後面
void add_to_head(int x)
{
    e[idx] = x;		// 儲存新節點
    ne[idx] = head;	// 第一步
    head = idx++;	// 第二步
}

將 x 這個點插入到下標是 k 的節點後面

1. 將插入的節點儲存
2. 將插入的節點的下一個節點的下標指向 k 節點的下一個節點
3. 將 k 節點的下一個節點下標指向插入節點
4. 當前用到的節點編號++

// 將值為x的節點插入到第k個節點的後面
void add(int k, int x)
{
    e[idx] = x;		// 儲存新節點
    ne[idx] = ne[k];	// 將新節點指向k節點後面的節點
    ne[k] = idx ++;	// 將節點k的下一個節點指向插入節點x
}
 

刪除節點下標是 k 的後面的節點

將下標是 k 的節點的下一個節點指向下下個節點，也就是說跳過 k 後面那個節點

// 將下標是k的節點後面的節點刪除
void remove(int k)
{
    ne[k] = ne[ne[k]];
}

例題

826. 單鏈表 - AcWing題庫

#include <iostream>
using namespace std;

const int N = 1e5 + 5;
int e[N], ne[N], head, idx;

// 初始化
void init()
{
    head = -1;
    idx = 0;
}

// 連結串列頭插入元素
void add_to_head(int x)
{
    e[idx] = x;
    ne[idx] = head;
    head = idx++;
}

// 在下標是k的節點後插入值為x的節點
void add(int k, int x)
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx ++;
}

// 刪除下標是k節點後面的點
void remove(int k)
{
    ne[k] = ne[ne[k]];
}

int main()
{
    init();		// 首先要初始化
    int T, x, k;
    char op;
    cin >> T;
    while(T--)
    {
        cin >> op;
        if(op == 'H')
        {
            cin >> x;
            add_to_head(x);
        }
        else if(op == 'D')
        {
            cin >> k;
            if(k == 0) head = ne[head];	// 刪除頭節點
            else remove(k - 1);
        }
        else{
            cin >> k >> x;
            add(k - 1, x);
        }
    }
    for(int i = head; i != -1; i = ne[i])
        cout << e[i] << " ";
    return 0;
}