十一、数据结构——双链表

一、基本思路

1、双链表初始化结构

• 注意：
• 1. 首尾结点需要进行定义，占用了0 与 1的结点，故此 idx 是需要在第二个数组开始
• 2. 双指针需要存左右指针

2、在第 k 个数后面插入一个数

• 1. 创建新节点前后连接
     
• 2. 第 k 个数与原来 k + 1 归位
     
• 3. 注意：
• • 若是在 k 结点左边插入一个结点，则可以使用 add（L【k】，x），将前面结点的后面进行添加
• • 注意在 k 的左边插入行并不等于在 （k - 1）右边插入，因为插入操作的存在，导致 k 的左边不一定是 k - 1

3、删除第 k 个插入值所在节点

这里是引用

• 动两个指针即可

二、Java、C语言模板实现

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

public class Main {
    static int N = 100010;
    static int idx;
    static int[] e = new int[N];
    static int[] left = new int[N];
    static int[] right = new int[N];

    public static void init(){
        right[0] = 1;               // 头结点的右边指针指向节点1，但是后面可能会更换；
                                    // 进行最左侧插入一个数操作的时候，因为insert实际是在k节点后面增加节点，所以就相当于在0节点后面加一个节点
        left[1] = 0;                // 尾结点的左节点指向节点0，但是后面需要变换
                                    // 进行最右侧插入一个数操作的时候，因为insert实际是在k节点后面增加节点，那也就是在1节点前面插入，也就是left【1】后面

        idx = 2;                    // 表示一开始就已经存在了头结点 0 与尾结点 1，所以从2节点开始记录，这两个也一直都是首尾结点
                                    // 要注意后面的坐标变换，第k个插入的数，实际在坐标为k + 1处的数组
    }

    public static void insertNode(int k, int x){        // 在第 k 个插入的数后面插入节点
        e[idx] = x;
        right[idx] = right[k];;
        left[idx] = k;
        left[right[k]] = idx;
        right[k] = idx++;
    }

    public static void deleteNode(int k){               // 删除第 k 个插入的节点
        right[left[k]] = right[k];
        left[right[k]] = left[k];
    }

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

        for (int i = 0; i < M; i++) {
            String judge = scanner.next();

            switch (judge){
                case "L":
                    x = scanner.nextInt();
                    insertNode(0, x);           // 进行最左侧插入一个数操作的时候，因为insert实际是在k节点后面增加节点，所以就相当于在0节点后面加一个节点
                    break;
                case "R":
                    x = scanner.nextInt();
                    insertNode(left[1], x);        // 进行最右侧插入一个数操作的时候，因为insert实际是在k节点后面增加节点，那也就是在1节点前面插入，也就是left【1】后面
                    break;
                case "D":
                    k = scanner.nextInt();
                    deleteNode(k + 1);          // idx 从索引2开始存储节点，第k个插入的数，即为k + 1节点
                    break;
                case "IL":
                    k = scanner.nextInt();
                    x = scanner.nextInt();
                    insertNode(left[k + 1], x);     // 此处要注意，第k个节点的左边不一定是 k - 1,因为存在删除操作
                    break;
                case "IR":
                    k = scanner.nextInt();
                    x = scanner.nextInt();
                    insertNode(k + 1,x);
                    break;
            }
        }

        for(int i = right[0];i != 1; i = right[i]){ // 注意此处一直到尾结点 1
            System.out.print(e[i] + " ");
        }
    }

}

```c
// C语言实现，此处是yxc实现
// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;

// 初始化
void init()
{
    //0是左端点，1是右端点
    r[0] = 1, l[1] = 0;
    idx = 2;
}

// 在节点a的右边插入一个数x
void insert(int a, int x)
{
    e[idx] = x;
    l[idx] = a, r[idx] = r[a];
    l[r[a]] = idx, r[a] = idx ++ ;
}

// 删除节点a
void remove(int a)
{
    l[r[a]] = l[a];
    r[l[a]] = r[a];
}

三、注意事项

• 重要：
• 需要注意使用 idx 进行存储和第 k 个数存储的关系，有可能加一，也有可能减一，影响到后面在第k 个数后面插入函数的坐标，这涉及到具体情况，需要细细分析。