数据结构（一）——链表

链表与邻接表

介绍

链表作为一种基础数据结构，具有几个特点：

• 优点：插入、删除非常快（需要知道需要插入和删除节点前一个位置）
• 缺点：查询、访问（用索引）非常的慢

链表的创建方法一般有如下几种：

• 动态链表：结构体+指针（不适合做题用，容易因new Node();超时）

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

  这种实现方式，每次创建新建节点，都需要调用一次new函数，但是这个新建过程非常慢，在笔试题中链表长度一般是1e5或者是1e6，new完这些节点基本上就直接超时了。

• 静态链表：用两个数组表示val和next，用于模拟链表

  • 数组模拟单链表，在算法题和笔试里常用于构建邻接表（存储图和树），邻接表即多个单链表
  • 数组模拟双链表，用于优化某些问题

核心思想：

接下来介绍静态链表的实现。

单链表：用两个数组来表示链表，结点的位置用下标来代替，这里需要注意，下标是指插入的次序，也就是说最后的链表从头至尾节点下标是保序的但并非是等差的。e[N]表示N个节点的val值，ne[N]表示N个节点的next节点的下标。另外还需要定义一个head整形变量用于保存第一个结点的下标。

这里实现四个需求，四个函数：

1. 初始化；init();
2. 向链表头插入一个数；head_insert(int x);
3. 删除第 k 个插入的数后面的数；remove(int k);
4. 在第 k 个插入的数后插入一个数。add(int k, int x);

多链表：和单链表不同的地方在于，每一个节点不仅有指向后一个结点的指针，还有指向前一个结点的指针。因此这里需要多定义一个数组l[N]代表每个结点指向的上一个结点，另外链表的初始化需要直接占用两个结点，分别是首元结点和尾结点。

这里实现六个需求，两个函数：

1. 初始化；init()
2. 在最左侧插入一个数；add(0, x)
3. 在最右侧插入一个数；add(l[1], x)
4. 将第 k 个插入的数删除；remove(int k);
5. 在第 k 个插入的数左侧插入一个数；add(int k, int x);
6. 在第 k 个插入的数右侧插入一个数；add(int l[k], int x)

这里需要注意，一个插入函数可以通过改变传入参数满足4和5两个需求

模板代码：

单链表：

// 单链表：
int head, e[N], ne[N], idx;


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


// 头插
void head_insert(int x)
{
    ne[idx] = head; // 新节点指向头头指针指向结点
    head = idx; // 头指针指向新节点
    e[idx] = x; // 新节点赋值
    idx++; // idx后移到下一个未使用的节点
}
// head_insert(x);


// 在第k个插入结点的后面添加val=x的结点
void add(int k, int x)
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx;
    idx++;
}
// add(k-1, x);


// 删除第k个插入的结点
void remove(int k)
{
    ne[k] = ne[ne[k]];
}
// if (!k) head = ne[head];
// else remove(k - 1);

多链表 ：

// 多链表：
int e[N], l[N], r[N], idx;


// 初始化
void init()
{ 
	r[0] = 1, l[1] = 0;
    idx = 2; // 0和1已经被占用
}


// 在第k个插入的结点后插入val = x的结点
void add(int k, int x)
{
	e[idx] = x;
    r[idx] = r[k];
    l[idx] = k;
    l[r[k]] = idx;
    r[k] = idx;
    idx++;
}
// add(0, x); // 头插
// add(l[1], x); // 尾插
// add(k, x); // 在第k个结点的右侧插入结点
// add(l[k], x); // 在第k个结点的左侧插入结点


// 删除第k个插入的结点
void remove(int k)
{
    r[l[k]] = r[k];
    l[r[k]] = l[k];
}
// remove(k);

例题1：单链表

代码：

#include<iostream>
using namespace std;

const int N = 1e5 + 10;

int head, e[N], ne[N], idx;

void init()
{
    head = -1;
    idx = 0;
}

void head_insert(int x)
{
    ne[idx] = head; // 新节点指向头头指针指向结点
    head = idx; // 头指针指向新节点
    e[idx] = x; // 新节点赋值
    idx++; // idx后移到下一个未使用的节点
}

void add(int k, int x)
{
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx;
    idx++;
}

void k_delete(int k)
{
    ne[k] = ne[ne[k]];
}

int main()
{
    int m;
    cin >> m;
    init();
    
    while(m -- )
    {
        char c;
        int k, x;
        cin >> c;
        
        if(c == 'H')
        {
            cin >> x;
            head_insert(x);
        }
        if(c == 'D')
        {
            cin >> k;
            if(k) k_delete(k-1);
            else head = ne[head];
        }
        if(c == 'I')
        {
            cin >> k >> x;
            add(k-1, x);
        }
    }
    
    for(int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';
    cout << endl;
    
    return 0;
}

例题2：双链表

代码：

#include<iostream>
using namespace std;
 
const int N = 1e5 + 10;

int l[N], r[N], idx, e[N];

void init()
{
    r[0] = 1, l[1] = 0;
    idx = 2;
}

void add(int k, int x)
{
    e[idx] = x;
    l[idx] = k;
    r[idx] = r[k];
    l[r[k]] = idx;
    r[k] = idx;
    idx++;
}

void remove(int k)
{
    r[l[k]] = r[k];
    l[r[k]] = l[k];
}

int main()
{
    init();
    int m; cin >> m;
    string op;
    int k, x;
    
    while( m -- )
    {
        cin >> op;
        if(op == "L")
        {
            cin >> x;
            add(0, x);
        }
        else if(op == "R")
        {
            cin >> x;
            add(l[1], x);
        }
        else if(op == "D")
        {
            cin >> k;
            remove(k+1);
        }
        else if(op == "IL")
        {
            
            cin >> k >> x;
            add(l[k+1], x);
        }
        else
        {
            cin >> k >> x;
            add(k+1, x);
        }
        
    }
    
    for(int i=r[0]; i!=1; i=r[i]) cout << e[i] << " ";
    cout << endl;
}