.单链表.

news2024/5/18 17:38:58

单链表就是将所要求得的数据呈现在一条链上进行求解。(用一种链式结构存储数据，这种结构就称之为链表)

题目：

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

向链表头插入一个数；
删除第 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）。

输出格式

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

数据范围

1≤M≤1000001≤𝑀≤100000
所有操作保证合法。

输入样例：

输出样例：

6 4 6 5

我的理解

从这个模拟也可以看出，由于数组下标从0开始，所以k=m对应的指针为m-1.

代码：

//链表
#include<iostream>

using namespace std;

const int N=1e5+10;
//n[N]表示当前节点的值 
//ne[N]表示当前节点的下一指针是多少
//head表示头节点的指针（下标）
int n[N],ne[N],head;
int m;
//表示当前正在使用节点的值（idx 存储当前已经用到了哪个点）
//idx也表示当前时第几次插入。当idx=0时表示第一次插入，idx=3时表示第四次插入。(因为数组从0开始)
int idx;
void fir()
{
/*
头节点指针之所以为-1，是因为头节点在数组里本来就不存在
在这里抽象出来一个头节点是为了后续在头部的插入
而赋初值为-1是为了区分数组的第一个指针0
如果让idex赋初值为1，head=0也是可以的。目的是为了区分
*/
    head=-1;
    idx=0;
}
//将数值x插入到头节点
void add_to_head(int x)
{
    //先将指针idx指向的值x记录下来
    n[idx]=x;
    //指针idx的next指向应该指向头节点的next指向
    ne[idx]=head;
    //指针头节点的指向指针idx
    head=idx;
    //方便后续调用
    idx++;
}

//将数值x插入下标是k的后面
void add(int k,int x)
{
    //先将指针idx指向的值x记录下来
    n[idx]=x;
    //既然是插入到k节点的后面，那么指针的next指向就应该指向k的next指向
    ne[idx]=ne[k];
    //指针k的指向指针idx
    ne[k]=idx;
    //idx自加
    idx++;
}

//将下表为k的下一节点删掉
void remove(int k)
{
    //既然是将下表为k的下一节点删掉，那么直接忽略掉下一节点的指针
    //将指针k的next指向，指向指针k的next next指向(跳过k的下一节点)
    ne[k]=ne[ne[k]];
}

int main()
{
    fir();
    cin >> m;
    while(m--)
    {
        char a;
        cin >>a;
        if(a=='H')
        {
            int x;
            cin >>x;
            add_to_head(x);
        }
        else if(a=='D')
        {
            int k;
            cin >>k;
//对头节点进行特判，如果k=0即删除头节点。那直接将头节点的指针指向它的下一个指针，即舍弃头节点。
            if(!k) head=ne[head];
            remove(k-1);
        }
        else if(a=='I')
        {
            int x,k;
            cin >> k >> x;
            add(k-1,x);
        }
    }
//i=-1时为空集，每次循环结束指针i都指向下一个指针
//i初始等于头指针
    for(int i=head;i!=-1;i=ne[i]) cout << n[i] << " ";
    return 0;
}
//下面附上head=0，idex=1的算法(评论区的佬写的)：

/*
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int cur=1, e[N], ne[N];

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

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


int main()
{
    int m; cin >> m;
    while (m--) {
        char op; int k,x;
        cin >> op;
        if (op == 'H') {
            cin >> x;
            add_k(0,x);
        } else if (op == 'I') {
            cin >> k >> x;
            add_k(k,x); 
        } else {
            cin >> k;
            del_k(k);
        }
    }

    for (int j = ne[0]; j ; j = ne[j]) cout << e[j] << ' ';
    cout << endl;
    return 0;
}
*/