基础--数组模拟单链表，双链表，栈，队列

姜九笙561

已于 2024-01-25 21:28:50 修改

阅读量921

点赞数 18

分类专栏：算法学习文章标签：算法数据结构 java

于 2024-01-25 21:23:21 首次发布

本文链接：https://blog.csdn.net/weixin_63001635/article/details/135853634

版权

算法学习专栏收录该内容

32 篇文章 0 订阅

订阅专栏

单链表

邻接表（n个单链表）；用于存储图和树

双链表

优化问题

单链表:

e[] 存储值

ne[]存储下一位的位置，相当于链表中的next()

head：头结点下标

idx：当前在数组中存储到的位置

实现一个单链表，链表初始为空，支持三种操作：

向链表头插入一个数；
删除第 k 个插入的数后面的数；
在第 k 个插入的数后插入一个数。

现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。

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

输入格式

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

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

H x，表示向链表头插入一个数 x。
D k，表示删除第 k 个插入的数后面的数（当 k 为 00 时，表示删除头结点）。
I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 00）。

输出格式

共一行，将整个链表从头到尾输出。

import java.util.*;
import java.io.*;

class Main{
    static int N  = 100010; // 数组最大长度，加10保险
    static int n,idx,head = -1; // 数组长度，存储位置，头结点
    static int[] e = new int[N]; // 存值
    static int[] ne = new int[N]; // 存下一个节点位置next()
    public static void main(String[] args) throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(in.readLine());
        
        while(n-->0){
            String[] str = in.readLine().split(" ");
            if(str[0].equals("H")){//头插
                add_to_head(Integer.parseInt(str[1]));
            }
            else if(str[0].equals("D")){//删除
                if(Integer.parseInt(str[1])==0) 
                    head = ne[head];
                else 
                    delete(Integer.parseInt(str[1])-1);
            }
            else{ // 插入到k位置
                add(Integer.parseInt(str[1])-1,Integer.parseInt(str[2]));
            }
        }
        for(int i=head;i!=-1;i=ne[i]){
            System.out.print(e[i]+" ");
        }
    }
    // 头插
    public static void add_to_head(int x){
        e[idx] = x;
        ne[idx] = head;
        head = idx;
        idx++;
    }
    // 删除
    public static void delete(int k){
        ne[k] = ne[ne[k]];
    }
    // 插入到第k个位置
    public static void add(int k,int x){
        e[idx] = x;
        ne[idx] = ne[k];
        ne[k] = idx;
        idx++;
    }
}

双链表

e[] ：存值

l[] ：左节点位置

r[] ：右节点位置

head，tail ：左端点（在数组中0位置表示左端点），右端点（1位置表示右端点）

init(): r[0] = 1; l[1] = 0 ; idx = 2;

实现一个双链表，双链表初始为空，支持 55 种操作：

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

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

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

输入格式

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

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

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

输出格式

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

画图理解：

import java.util.*;

class Main{
    static final int N = 100010; // 给定的数据范围+10
    static int n; // 链表长度
    static int idx;
    static int[] e = new int[N]; // 存值
    static int[] l = new int[N]; // 左节点位置
    static int[] r = new int[N]; // 右节点位置
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        init();
        while(n-->0){
            String s = in.next();
            if(s.equals("R")){  //尾插
                int x = in.nextInt();
                add(l[1],x); // 相当于在最后一个节点的右边插入一个
            }
            else if(s.equals("D")){ // 删除
                int k = in.nextInt();
                    remove(k+1);
            }
            else if(s.equals("L")){  // 头插
                int x = in.nextInt();
                add(0,x);
            }
            else if(s.equals("IL")){  // 在k位置节点的左边插入一个节点
                int k = in.nextInt();
                int x = in.nextInt();
                add(l[k+1],x);  // 相当于在k位置的前一个节点的右边插入一个节点
            }
            else{  // 在k位置的右边插入一个节点
                int k = in.nextInt();
                int x = in.nextInt();
                add(k+1,x);
            }
        }
        int i = r[0];
        while(i!=1){
            System.out.print(e[i]+" ");
            i = r[i];
        }
        
    }
    // 初始化
    static void init(){
        r[0] = 1;
        l[1] = 0;
        idx=2;
    }
    // 添加
    static void add(int k,int x){
        e[idx] = x;
        r[idx] = r[k];
        l[idx] = k;
        l[r[k]] = idx;
        r[k] = idx;
        idx++;
    }
    // 删除
    static void remove(int k){
        r[l[k]] = r[k];
        l[r[k]] = l[k];
    }
    
}