【AcWng算法学习日志】数据结构基础（1）

蒟蒻算法小白重新开始学习，存一下看了视频和大佬题解重打的代码和自己的一些理解注释。

单链表

模板题

实现一个单链表，链表初始为空，支持三种操作：
（1）向链表头插入一个数；
（2）删除第 k 个插入的数后面的数；
（3）在第 k 个插入的数后插入一个数。
现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。
注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。
输入格式
第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：
H x，表示向链表头插入一个数 x。
D k，表示删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）。
I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 0）。
输出格式
共一行，将整个链表从头到尾输出。

#include <iostream>
#include <cstdio>

using namespace std;

//数组模拟单链表
//head存储链表头，e[]存储节点的值
//ne[]存储next指针，idx表示当前用到了哪个节点

const int N=100010;
int head,e[N],ne[N],idx;
//idx代表着节点的下标，节点是靠ne[]来连接的。

void init(){ //初始化
    head=-1; //可将head看作一个指针，初始时链表为空指向-1
    idx=0;
}

void insert(int a){ //向链表头插入一个数
    e[idx]=a;//第idx个节点的值为a
    ne[idx]=head;//这个节点指向head原本指向的节点
    head=idx;//head指针指向新插入的这个节点
    idx++;//idx后移一位
    //也可写作 head=idx++;
}

void add(int k,int x){ //在第k个节点后插入x
    e[idx]=x;
    ne[idx]=ne[k];
    ne[k]=idx;
    idx++;
}

void remove(int k){ //删除下标为k的点的后面的节点
    ne[k]=ne[ne[k]]; //不一定是ne[k+1]，下标为k的节点未必指向下标k+1的节点
}


int main()
{
    int m;
    cin>>m;
    init();
    while(m--){
        int k,x;
        char c;

        cin>>c;
        if(c=='H'){
            cin>>x;
            insert(x);
        }
        if(c=='D'){
        //用idx来记录用到了第几个点，即第一次插入的点idx=0，第二次插入的点idx=1...第k次插入的节点的下标即为k-1
            cin>>k;
            if(k==0) head=ne[head];//删除头节点单独列出
            remove(k-1);//第k个插入的节点的下标是k-1（从0开始）
        }
        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;
}

双链表

模板题

实现一个双链表，双链表初始为空，支持 5 种操作：
（1）在最左侧插入一个数；
（2）在最右侧插入一个数；
（3）将第 k 个插入的数删除；
（4）在第 k 个插入的数左侧插入一个数；
（5）在第 k 个插入的数右侧插入一个数
（6）现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。
注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。
输入格式
第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：
L x，表示在链表的最左端插入数 x。
R x，表示在链表的最右端插入数 x。
D k，表示将第 k 个插入的数删除。
IL k x，表示在第 k 个插入的数左侧插入一个数。
IR k x，表示在第 k 个插入的数右侧插入一个数。
输出格式
共一行，将整个链表从左到右输出。

#include<iostream>
using namespace std;

const int N=100010;
int m,e[N],idx,l[N],r[N];

void init(){
    //链表为空时设置两个节点，左节点编号为0，右节点为1
    //他们不储存数据，辅助确定链表的头尾，与单链表的head类似
    //通常不算时链表中的节点
    r[0]=1,l[1]=0;
    idx=2;//因此其他节点从二号开始
}

void insert(int a,int x){//在节点a右边插入x
    //如果要在a的左边插入x，即insert(l[a],x);
    e[idx]=x;
    l[idx]=a,r[idx]=r[a];//先设置a的左右指针，顺序不影响
    l[r[a]]=idx,r[a]=idx;//此处注意顺序，用左右指针中的哪一个表示另一个时，这个指针要后定义
    idx++;
}

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


int main(){
    cin>>m;

    init();

    while(m--){
        int x,k;
        string c;//注意细节，此处IL为两个字符，不能用char，用string
        cin>>c;

        if(c=="L"){
            cin>>x;
            insert(0,x);
        }
        if(c=="R"){
            cin>>x;
            insert(l[1],x);
        }
        if(c=="D"){
            cin>>k;
            remove(k+1);
        }
        if(c=="IL"){
            cin>>k>>x;
            insert(l[k+1],x);
        }
        if(c=="IR"){
            cin>>k>>x;
            insert(k+1,x);
        }

    }

    for(int i=r[0];i!=1;i=r[i]) printf("%d ",e[i]);
    return 0;
   }

模拟栈

实现一个栈，栈初始为空，支持四种操作：
(1)push x – 向栈顶插入一个数 x；
(2)pop – 从栈顶弹出一个数；
(3)empty – 判断栈是否为空；
(4)query – 查询栈顶元素。
现在要对栈进行 M 个操作，其中的每个操作 3 和操作 4 都要输出相应的结果。
输入格式
第一行包含整数 M，表示操作次数。
接下来 M 行，每行包含一个操作命令，操作命令为 push x，pop，empty，query 中的一种。
输出格式
对于每个 empty 和 query 操作都要输出一个查询结果，每个结果占一行。
其中，empty 操作的查询结果为 YES 或 NO，query 操作的查询结果为一个整数，表示栈顶元素的值。

#include<iostream>
using namespace std;

const int N=100010;
int stk[N],tt=0;//tt表示栈顶

int main(){
    int m;
    cin>>m;

    while(m--){
        string s;
        int x;
        cin>>s;
        if(s=="push"){//向栈顶插入元素x
            cin>>x;
            stk[++tt]=x;
        }
        if(s=="pop"){//栈顶弹出一个元素
            tt--;
        }
        if(s=="empty"){//判断栈是否为空
            if(tt>0) printf("NO\n");
            else printf("YES\n");
        }
        if(s=="query"){//查询栈顶的值
            cout<<stk[tt]<<endl;
        }
    }

    return 0;
}

一道有点麻烦的题目
表达式求值

给定一个表达式，其中运算符仅包含 +,-,*,/（加 减 乘 整除），可能包含括号，请你求出表达式的最终值。
注意：
数据保证给定的表达式合法。
题目保证符号 - 只作为减号出现，不会作为负号出现，例如，-1+2,(2+2)*(-(1+1)+2) 之类表达式均不会出现。
题目保证表达式中所有数字均为正整数。
题目保证表达式在中间计算过程以及结果中，均不超过 231−1。
题目中的整除是指向 0 取整，也就是说对于大于 0 的结果向下取整，例如 5/3=1，对于小于 0 的结果向上取整，例如 5/(1−4)=−1。
C++和Java中的整除默认是向零取整；Python中的整除//默认向下取整，因此Python的eval()函数中的整除也是向下取整，在本题中不能直接使用。
输入格式
共一行，为给定表达式。
输出格式
共一行，为表达式的结果。

#include<iostream>
#include<stack>
#include<unordered_map>
using namespace std;

stack<int> num;//存储运算数字
stack<char> op;//存储运算符
unordered_map<char,int> cmp{
    {'+',1},{'-',1},{'*',2},{'/',2}
};

void eval(){//模拟运算
    int b=num.top(); num.pop();//第二个操作数
    int a=num.top(); num.pop();//第一个操作数
    char opr=op.top(); op.pop();

    int tmp;
    if(opr=='+') tmp=a+b;
    else if(opr=='-') tmp=a-b;
    else if(opr=='*') tmp=a*b;
    else tmp=a/b;
    num.push(tmp);
}


int main(){
    string str;
    cin>>str;

    for(int i=0;i<str.size();i++){
        char c=str[i];

        if(isdigit(c)){//读入数字
            int j=i,x=0;
            while(j<str.size() && isdigit(str[j])){
            //如果str[i]是数字，则j向后移动，将这个数字读完
                x=x*10+str[j++]-'0';
            }
            //直到碰到一个运算符or算式结尾
            num.push(x);//将读出的数x压到数字栈中
            i=j-1;//i应为j，但for循环中i还会++，故为j-1
        }

        else if(c=='('){//左括号存入运算符栈
            op.push(c);
        }
        else if(c==')'){
            //读到一个右括号，即读完了一对完整的括号，应先算这一对括号里的内容
            while(op.size() && op.top()!='(') eval();//一直计算到左括号（栈是从上往下读）
            op.pop();//左括号出栈
        }
        else{
            while(op.size() && cmp[op.top()]>=cmp[c]) eval();
            //如果下一个将读入的运算符优先级低于或等于上一次的，则先计算上一次的
            //两者优先级相同，即要根据从左到右的规则计算，必须先算上一次的
            //如2-3+4
            //如果不计算，则最终从栈中读出则为2-（3+4）
            //因为模拟的运算是从右到左两个数一组计算
            //所以留下来的必须是右边的优先级高于左边
               
            op.push(c);//压入新的运算符
        }
    }

    //读完一遍之后清理剩下运算符
    while(op.size()) eval();
    cout<<num.top()<<endl;
    return 0;
}