十、数据结构——单链表

一、基本思路

1、单链表节点结构图

• 其中的 idx 表示的是当下要把第 k 个节点存在哪个索引的数组，要注意第k次插入和idx的关系
• 插入操作，第一步要先进行赋值
• 本链表为静态链表表示方式

2、将数值 x 插入到头结点

3、将数值 x 插入到第 k 次插入的数后面

4、将第 k 次插入的数后面的数删除

二、Java、C语言模板实现

//Java 模板实现
import java.util.*;

public class Main {
    static int N = 100010;
    static int[] e = new int[N];
    static int[] ne = new int[N];
    static int head, idx;

    public static void init(){
        head = -1;      // 我们用 -1 代表的是空集，其实此处就仅仅是一个头指针，指向的是next节点空集
        idx = 1;        // idx 指的是第 idx 插入节点，和链表的前后顺序无关，只是和插入顺序有关，插入多少次idx就应该是多少次
        // 或者说这是节点在数组中 index，如果初始值是0，那么这就是第k次插入，对应坐标是从0 —— k-1，后面对应k就应该是k - 1
        // 如果初始值是1，那也就意味着数组是从index = 1 开始存储的
    }

    public static void addHead(int x){
        e[idx] = x;
        ne[idx] = head;                     // 此处在一开始的时候，代表了此节点下一个是空集
        head = idx++;                       // head指向了当前新加入的节点
    }

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

    public static void deleteNode(int k){
        ne[k] = ne[ne[k]] ;     // 注意此处第 k 个插入后面不一定是第 k - 1 的插入节点,要用ne[k]，而非是ne[k + 1]
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int x,k;

        init();
        for (int i = 0; i < M; i++) {

            String judge = scanner.next();
            switch (judge){
                case "H":
                    x = scanner.nextInt();
                    addHead(x);
                    break;
                case "D":
                    k = scanner.nextInt();
                    if (k == 0){
                        head = ne[head];
                    }else {
                        deleteNode(k);      // 注意此处的 k 代表的是node在数组中的索引值，需要考虑第一个是不是从1开始计算
                    }
                    break;
                case "I":
                    k = scanner.nextInt();
                    x = scanner.nextInt();
                    insertNode(k, x);
                    break;
                default:
                    System.out.println("输入错误");
            }

        }


        // 输出链表
        for (int i = head; i != -1; i = ne[i]) {
            System.out.print(e[i] + " ");
        }

    }
}

```c
// C语言实现，此处是yxc实现
#include <iostream>

using namespace std;

const int N = 100010;


// head 表示头结点的下标
// e[i] 表示节点i的值
// ne[i] 表示节点i的next指针是多少
// idx 存储当前已经用到了哪个点
int head, e[N], ne[N], idx;

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

// 将x插到头结点
void add_to_head(int x)
{
    e[idx] = x, ne[idx] = head, head = idx ++ ;
}

// 将x插到下标是k的点后面
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()
{
    int m;
    cin >> m;

    init();

    while (m -- )
    {
        int k, x;
        char op;

        cin >> op;
        if (op == 'H')
        {
            cin >> x;
            add_to_head(x);
        }
        else if (op == 'D')
        {
            cin >> k;
            if (!k) 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] << ' ';
    cout << endl;

    return 0;
}

三、注意事项

• 单链表其实可以在任意位置插入，但是若想时间复杂度为O(1)，则只能在某一个点后面插入
• 原因：因为找不到上一个点的指针，只能从头遍历