数据结构基础报告

目录

• 栈结构+栈的应用-----关于表达式求值

• 模拟队列

• KMP字符串

• 并查集的基本操作和简单应用+食物链

一.栈结构+栈的应用-----关于表达式求值

1.栈结构

实现一个栈，栈初始为空，支持四种操作：

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 操作的查询结果为一个整数，表示栈顶元素的值。

数据范围

1≤M≤100000,
1≤x≤10^9
所有操作保证合法。

输入样例：

10
push 5
query
push 6
pop
query
pop
empty
push 4
query
empty

输出样例：

5
5
YES
4
NO

 题目要求就是栈的四个基本操作，所以代码贴这

#include<iostream>
#include<cstring>
using namespace std;
int p=-1;
int m[100000]={0};
//是否为空
bool empty()
{
    if(p==-1)
    {
        return 1;
    }
    return 0;
}
//求栈顶元素
void query()
{
    if(!empty())
    {
        cout<<m[p]<<endl;
    }
    return ;
}
//放入一个元素
void push(int x)
{
    m[++p]=x;
    return;
}
//弹出栈顶元素
void pop()
{
    if(!empty())
    {
        p--;   
    }
    return;
}

int main()
{
    int t=0;
    string o;
    cin>>t;
    while(t--)
    {
        cin>>o;
        if(o=="pop")
        {
            pop();
        }
        else if(o=="push")
        {
            int x=0;
            cin>>x;
            push(x);
        }
        else if(o=="empty")
        {
            if(!empty())
            {
                cout<<"NO"<<endl;
            }
            else
            {
                cout<<"YES"<<endl;
            }
        }
        else if(o=="query")
        {
            query();
        }
    }
    return 0;
}

C++也有自带的stack容器实现栈操作

ps:别忘了头文件#include<stack>

数据存取：

• push(elem) ; //向栈顶添加一个元素
• pop();  //移除栈顶的第一个元素
• top();  //返回栈顶的第一个元素

大小操作：

• empty();  //判断栈是否为空(bool类型)
• size() ;  //返回栈的大小

 2.表达式求值

给定一个表达式，其中运算符仅包含 +,-,*,/（加 减 乘 整除），可能包含括号，请你求出表达式的最终值。

注意：

• 数据保证给定的表达式合法。
• 题目保证符号 - 只作为减号出现，不会作为负号出现，例如，-1+2,(2+2)*(-(1+1)+2) 之类表达式均不会出现。
• 题目保证表达式中所有数字均为正整数。
• 题目保证表达式在中间计算过程以及结果中，均不超过 2^31−1。
• 题目中的整除是指向 0 取整，也就是说对于大于 0 的结果向下取整，例如 5/3=1，对于小于 0 的结果向上取整，例如 5/(1−4)=−1。
• C++和Java中的整除默认是向零取整；Python中的整除//默认向下取整，因此Python的eval()函数中的整除也是向下取整，在本题中不能直接使用。

输入格式

共一行，为给定表达式。

输出格式

共一行，为表达式的结果。

数据范围

表达式的长度不超过 10^5。

输入样例：

(2+2)*(1+1)

输出样例：

8

 思路分析

要开一个stack<int>num专门存放数字，stack<char>op专门存放操作符，那么op从后面开始数，每一个操作符操作num里最后的两个数字。这道题有只有两个核心问题，一个是数字作为字符数组存放时，多位数被分成一位数的字符存放，影响计算；第二个就是优先级问题，包括括号优先级和乘除运算优先于加减运算。

1. 首先考虑在我们用char型数组存放读入的表达式后，仅有一位数的数字不必担心，但是两位数及两位以上的数字此时已经变成一个位数的字符存储，所以会影响后面的计算，那么解决方法就是在读取到连续数字时，用一个循环将其提取出来，直到遇到非数字的字符，就可以跳出循环，获得一个完整数字，将它放入到单独存放数字的数组中。
2. 接下来就要解决优先级问题，括号优先问题就是运用栈，先存放左括号" ( " ，当遇到一个右括号" ) "时,说明这个括号里的数要优先运算，计算完括号中的数后，存放到数组num中，将op栈中左括号弹出，因为括号里的数值已经计算出来了，括号随之消失，（右括号永不进栈，只是作为标识，遇到右括号说明此时有一个括号内的数可以优先计算了）。
3. 还有一个加减乘除优先级问题，常用解决法就是当即将放入栈op的符号优先级低于op栈顶的符号优先级，就先将栈中高优先级先计算完，再存入低优先级，栈中只剩下低优先级，就不会影响结果了。

#include<iostream>
#include<cstring>
#include<string>
#include<stack>
#include<cctype> //isdigit()的头文件名
#include<unordered_map>
using namespace std;
unordered_map<char,int>cp={{'+',1},{'-',1},{'*',2},{'/',2}};//利用哈希表设定加减乘除优先级，
//括号优先级为默认为零，2高于1，用来比较优先级大小
stack<int>num;//专门存放数字的数组
stack<char>op;//专门存放运算符的数组

void eval() //op栈顶元素的操作符对num栈顶最后两个数字做运算
{
    int b=num.top();
    num.pop();
    int a=num.top();
    num.pop();
    char c=op.top();
    op.pop();
    int n=0;
    if(c=='+') n=a+b;
    else if(c=='-') n=a-b;
    else if(c=='*') n=a*b;
    else n=a/b;
    num.push(n);
}
int main()
{
    string str;
    cin>>str;
    for(int i=0;i<str.size();i++)
    {
        char c=str[i];
        if(isdigit(c)) //isdigit()可以对字符进行判断是否为数字
        {
            int x=str[i]-'0';
            int j=i+1;
            //一直计算直到str[j]不是数字型字符
            while(j<str.size()&& isdigit(str[j])) 
            {
                x=x*10+str[j]-'0';
                j++;
            }
            i=j-1;
            num.push(x);
        }
        //处理括号优先级
        else if(c=='(')
        {
            op.push(c);
        }
        else if(c==')')
        {
            //将括号里的数全部做运算，变成一个数字，将括号删去
            while(op.top()!='(') eval();
            op.pop();
        }
        else
        {
            //解决乘除优于加减优先级
            while(op.size()&&cp[op.top()]>=cp[c]) eval();
            op.push(c);
        }
    }
    //最后再对栈中剩余元素做运算，若op栈中还剩下元素说明还有运算操作要做，
    //否则说明num里仅剩一位数，就是最终运算结果
    while(op.size()) eval();
    cout<<num.top()<<endl;
    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 操作的查询结果为一个整数，表示队头元素的值。

数据范围

1≤M≤100000,
1≤x≤10^9,
所有操作保证合法。

输入样例：

10
push 6
empty
query
pop
empty
push 3
push 4
pop
query
push 6

输出样例：

NO
6
YES
4

队列基本操作

#include<iostream>
#include<cstring>
using namespace std;
int q[100010];
int p=0,t=-1;
//p为队头，t为队尾
bool empty()
{
    if(p>t)
    {
        return 1;
    }
    return 0;
}
int query()
{
    if(!empty())
    {
        return q[p];
    }
    return 0;
}
void pop()
{
    if(!empty())
    {
        p++;
    }
}
void push(int x)
{
    q[++t]=x;
}
int main()
{
    int m=0;
    cin>>m;
    string s;
    while(m--)
    {
        cin>>s;
        if(s=="empty")
        {
            if(!empty())
            {
                cout<<"NO"<<endl;
            }
            else
            {
                cout<<"YES"<<endl;
            }
        }
        else if(s=="query")
        {
            cout<<query()<<endl;
        }
        else if(s=="pop")
        {
            pop();
        }
        else
        {
            int n=0;
            cin>>n;
            push(n);
        }
    }
    return 0;
}

C++也有自带的queue容器实现队列操作

ps:别忘了头文件#include<queue>

数据存取：

push(elem); //入队——往队尾添加元素
pop(); //出队——从队头删除一个元素
back(); //返回队尾元素
front(); //返回队头元素

大小操作：

empty(); //判断队列是否为空
size(); //返回队列大小

 三.KMP字符串

在我之前写的笔记中已经叙述过了

详情可见

KMP字符串（在一串字符中寻找与给出字符串相匹配的子字符串，配上代码和O（n）复杂度算法）_鈴鐸945的博客-CSDN博客

 四.并查集的基本操作和简单应用

1.并查集基本操作

以题可见

一共有 n 个数，编号是 1∼n，最开始每个数各自在一个集合中。

现在要进行 m 个操作，操作共有两种：

1. M a b，将编号为 a 和 b 的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
2. Q a b，询问编号为 a 和 b 的两个数是否在同一个集合中；

输入格式

第一行输入整数 n 和 m。

接下来 m 行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式

对于每个询问指令 Q a b，都要输出一个结果，如果 a 和 b 在同一集合内，则输出 Yes，否则输出 No。

每个结果占一行。

数据范围

1≤n,m≤10^5

输入样例：

4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4

输出样例：

Yes
No
Yes

 

 

 

 2.并查集简单应用

这题与上题一样也是运用并查集知识，在主函数做一点小小改动即可，就是记录下集合中的元素数量。

给定一个包含 n 个点（编号为 1∼n）的无向图，初始时图中没有边。

现在要进行 m 个操作，操作共有三种：

1. C a b，在点 a 和点 b 之间连一条边，a 和 b 可能相等；
2. Q1 a b，询问点 a 和点 b 是否在同一个连通块中，a 和 b 可能相等；
3. Q2 a，询问点 a 所在连通块中点的数量；

输入格式

第一行输入整数 n 和 m。

接下来 m 行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式

对于每个询问指令 Q1 a b，如果 a 和 b 在同一个连通块中，则输出 Yes，否则输出 No。

对于每个询问指令 Q2 a，输出一个整数表示点 a 所在连通块中点的数量

每个结果占一行。

数据范围

1≤n,m≤10^5

输入样例：

5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5

输出样例：

Yes
2
3

解答代码 

#include<iostream>
using namespace std;
int n,m,a,b;
string c;
int p[100010];
int s[100010];
int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        p[i]=i;
        s[i]=1;
    }
    while(m--)
    {
        cin>>c;
        if(c=="C")
        {
            cin>>a>>b;
            int t1=find(a),t2=find(b);
            if(t1!=t2)
            {
                //集合数量赋值要在根节点转变之前，因为根节点转变之后s中的t2变为了s[t1]，
                //就相当于s[t1]自加了
                s[t1]+=s[t2];
                p[t2]=t1;
            }
        }
        else if(c=="Q1")
        {
            cin>>a>>b;
            if(find(a)==find(b)) cout<<"Yes"<<endl;
            else cout<<"No"<<endl;
        }
        else
        {
            cin>>a;
            cout<<s[find(a)]<<endl;
        }
    }
    return 0;
}

3.并查集的提升应用（食物链）

这道题难度稍大，是中等题

动物王国中有三类动物 A,B,C，这三类动物的食物链构成了有趣的环形。

A 吃 B，B 吃 C，C 吃 A。

现有 N 个动物，以 1∼N 编号。

每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这 N 个动物所构成的食物链关系进行描述：

第一种说法是 1 X Y，表示 X 和 Y 是同类。

第二种说法是 2 X Y，表示 X 吃 Y。

此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假的。

当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

1. 当前的话与前面的某些真的话冲突，就是假话；
2. 当前的话中 X 或 Y 比 N 大，就是假话；
3. 当前的话表示 X 吃 X，就是假话。

你的任务是根据给定的 N 和 K 句话，输出假话的总数。

输入格式

第一行是两个整数 N 和 K，以一个空格分隔。

以下 K 行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中 D 表示说法的种类。

若 D=1，则表示 X 和 Y 是同类。

若 D=2，则表示 X 吃 Y。

输出格式

只有一个整数，表示假话的数目。

数据范围

1≤N≤50000,
0≤K≤100000

输入样例：

100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5

输出样例：

3

 下面是我自己的思路理解

 

 

 以上是数据结构基础章报告，有错误的话大家多多指教☺