DS博客作业02--栈和队列
0.PTA得分截图
1.本周学习总结
1.1 总结栈和队列内容
栈
- 栈的基本认识
栈（stack）：栈是限定仅在表的一端进行插入或删除操作的线性表。
我们把允许插入和删除操作的一端称为栈顶（top），另一端称为栈底（bottom）。不含任何数据元素的栈称为空栈。栈又称为“后进先出（Last In First Out，简称LIFO）的线性表”，简称为LIFO结构。
栈的插入操作，称为进栈/入栈/压栈。
栈的删除操作，称为出栈/弹栈。
不过要注意的是，最先进栈的元素不代表最后出栈。栈对线性表的插入删除位置做了限制，但并没有对出栈和入栈的时间做限制。也就是说，在不是所有元素都入栈的情况下，事先入栈的元素也可以在任意时间出栈，只要保证每次出栈的元素都是栈顶元素就可以。 - 栈的顺序存储结构
顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用地址连续的存储空间（数组)依次存储栈中数据元素，由于人栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处；栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置
顺序栈的结构定义：
typedef int SElemType;
typedef int Status;
struct SqStack
{
SElemType *base;
SElemType *top;
int stacksize;
};
- 顺序栈的操作
1.栈的初始化
Status InitStack(SqStack &S)
{
S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base) return OVERFLOW;
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
2.销毁栈
Status DestoryStack(SqStack &S)
{
free(S.base);
S.base = NULL;
S.top = NULL;
S.stacksize = 0;
return OK;
}
3.清空栈
Status ClearStack(SqStack &S)
{
S.top = S.base;
return OK;
}
4.判断栈空
Status StackEmpty(SqStack S)
{
if(S.top == S.base)
return TRUE;
else
return FALSE;
}
5.取栈长
int StackLength(SqStack S)
{
return S.top - S.base;
}
6.取栈顶
Status GetTop(SqStack S,SElemType &e)
{
if(S.top == S.base) return ERROR;
e = *(S.top -1);
return OK;
}
7.入栈
Status Push(SqStack &S, SElemType e)
{
if(S.top - S.base >= S.stacksize)
{
S.base = (SElemType *)realloc(S.base,(S.stacksize + STACKINCREMENT)*sizeof(SElemType));
if(!S.base) return OVERFLOW;
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}
8.出栈
Status Pop(SqStack &S, SElemType &e)
{
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}
- 栈的链式存储结构
对于顺序栈来说，主要的缺点就是栈的大小已经固定，若有超过栈长的元素个数，则此时栈会发生“溢出”。这时我们可以采用链式栈的存储结构，这样就不用再考虑栈的空间是否足够大的问题。
栈的链式存储结构，简称为链栈。
思考：对于栈的链式存储结构来说，栈顶指针是在链表头结点位置更好，还是在链表尾节点位置更好?
答：头结点位置更好
链表有头指针，而栈的主要操作也是在栈顶进行，那么我们就可以将二者合一，将单链表的头指针作为栈顶指针，即栈的链式存储结构的栈顶指针为单链表的头指针。
链栈的结构定义：
typedef char ElemType;
typedef struct linknode
{
ElemType data;
struct linknode *next;
}LinkStNode;LinkStNode *s;
- 链栈的操作
1.初始化栈
void InitStack(LinkStNode*&s)//初始化栈
{
cout<<"初始化栈"<<endl;
s=(LinkStNode*)malloc(sizeof(LinkStNode));
s->next=NULL;
}
2.进栈
void Push(LinkStNode*&s)//进栈
{
ElemType e;
int i=0;
LinkStNode *p;
cout<<"依次进栈的元素为:";
while (i<n)
{
cin>>e;
p=(LinkStNode*)malloc(sizeof(LinkStNode));
p->data=e;
p->next=s->next;
s->next=p;
i++;
}
}
3.判断栈空
void StackEmpty(LinkStNode *s)//判断栈是否为空
{
if(s->next==NULL)
{
cout<<"栈为空"<<endl;
}
else
cout<<"栈非空"<<endl;
}
4.取栈顶
void GetTop(LinkStNode*s)//得到栈顶元素
{
if(s->next!=NULL)
{
cout<<"栈顶元素为：";
cout<<s->next->data;
cout<<endl;
}
}
5.出栈
void Pop(LinkStNode *&s)//出栈操作
{
cout<<"出栈序列为：";
LinkStNode *p;
while(s->next!=NULL)
{
cout<<s->next->data<<" ";
p=s->next;
s->next=p->next;
free(p);
}
cout<<endl;
}
6.销毁栈
void DestroyStack(LinkStNode*&s)//释放栈
{
cout<<"释放栈";
LinkStNode *q=s,*p=s->next;
while(p!=NULL)
{
free(q);
q=p;
p=q->next;
}
free(q);
}
- 栈的应用：后缀表达式
对于数学运算来说，确定运算符的优先级是十分重要的，直接决定了该算式是否计算正确。在实际生活中，我们书写的算式都是中缀表达式，即运算符（此处特指算数运算符）在操作数中间。例如：
9+(3-1)*3+10/2
我们把这种平时使用的四则运算表达式的写法称为中缀表达式。但是对于计算机而言，中缀表达式并不方便。计算机计算都是从左到右顺序计算，在该算式中，*在+之后，但是却要先于+进行运算，而加入括号后，运算则会变得更加复杂。
对于四则运算，20世纪50年代，波兰逻辑学家Jan Lukasiewicz发明了一种不需要括号的表达式方法，称为后缀表示法，也称为逆波兰（Reverse Polish Notation，简称RPN）表示法。
那么，如何把中缀表达式转化为后缀表达式呢？方法：
从左至右遍历中缀表达式的每个数字和符号，按照以下规则，直到最终输出后缀表达式：
使用map容器将-+和1配对，*/和2配对，（和3配对
for 遍历字符串
if 遇到) then 一直出栈至遇到(为止
else if 遇到数字或者小数点 then 直接出栈
else if 遇到(+ || -)&&(在第一位 || 前面不是数字不是) ) (为正负号) then
直接出栈
else if 遇到运算符 then
while 栈不空
if 运算符优先级大于栈顶优先级 或 栈顶为(
直接入栈
否则 出栈
end if
end while
if 栈空 then 运算符入栈
end if
遍历完字符串后 if 栈不空 then
一直出栈至栈空
end if
我们以下面的算式为例进行讲解
9+(3-1)*3+10/2------>9 3 1 - 3 * + 10 2 / +
1.初始化一个空栈，用于对符号进出栈使用。
2.第一个数字是9，输出9。后面的符号+入栈。
3.第三个字符是（，依然是符号，因其是左括号还未配对，故进栈。
4.第四个字符是数字3，输出，此时表达式为9 3，接着符号-进栈。
5.接下来是数字1，输出，此时表达式为9 3 1，后面是符号），此时我们需要把（之前的所有元素都出栈，直至输出（为止。此时总的表达式是9 3 1 -。
6.紧接着是符号，因为此时的栈顶符号是+，优先级低于，因此不输出，进栈。紧接着是数字3，输出，总表达式为9 3 1 – 3.
7.之后是符号+，此时栈顶元素是，比+优先级高，因此栈中元素出栈并输出（因为没有比+更低优先级的符号，所以全部出栈），总输出表达式为9 3 1 – 3 * +。然后将这个符号+进栈。
8.紧接着输出数字10，总表达式为9 3 1 – 3 * + 10。之后是符号/，所以/进栈。
9.最后一个数字为2，此时总表达式为9 3 1 – 3 * + 10 2。
10.因已到最后，所以将栈中符号全部出栈。最终获得的后缀表达式为9 3 1 – 3 * + 10 2 / +。
具体的代码实现如下：
#include<iostream>
#include<map>
#include<stack>
#include<string>
using namespace std;
void InfixToSuffix(string infix, string& suffix);
int main()
{
string infix;
string suffix;
cin >> infix;
InfixToSuffix(infix, suffix);
cout << suffix;
return 0;
}
void InfixToSuffix(string infix, string& suffix)
{
int i;
int len;
map<char,int> op;
stack<char> oper;
len = infix.length();
op['-'] = 1;op['+'] = 1;op['*'] = 2;op['/'] = 2;op['('] = 3;
for (i = 0;i <= len;i++)
{
if (infix[i] == ')')
{
while (oper.top() != '(')
{
suffix = suffix + oper.top() + ' ';
oper.pop();
}
oper.pop();
}
else if (isdigit(infix[i])||infix[i]=='.')
{
while (isdigit(infix[i]) || infix[i] == '.')
{
suffix += infix[i];
i++;
}
suffix += ' ';
i--;
}
else if ((infix[i] == '-' || infix[i] == '+') && (i == 0 || (infix[i - 1] != ')' && !isdigit(infix[i - 1]))))
{
if (infix[i] == '-')
{
suffix += infix[i];
}
}
else
{
while (!oper.empty())
{
if (op[infix[i]] > op[oper.top()] || oper.top() == '(')
{
oper.push(infix[i]);
break;
}
else
{
suffix = suffix + oper.top() + ' ';
oper.pop();
}
}
if (oper.empty())
{
oper.push(infix[i]);
}
}
}
while (!oper.empty())
{
suffix = suffix + oper.top() + ' ';
oper.pop();
}
suffix.erase(suffix.length() - 3);
}
队列
- 队列的基本认识
队列（queue）：队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入操作的一端称为队尾，允许删除操作的一端称为队头。
队列与现实生活中的排队机制很像，排在队头的出队，而想入队则只能从队尾开始。
队列的基本操作包括：
初始化队列：InitQueue（Q）
操作前提：Q为未初始化的队列。
操作结果：将Q初始化为一个空队列。
判断队列是否为空：IsEmpty（Q）
操作前提：队列Q已经存在。
操作结果：若队列为空则返回1，否则返回0。
判断队列是否已满：IsFull（Q）
操作前提：队列Q已经存在。
操作结果：若队列为满则返回1，否则返回0。
入队操作：EnterQueue（Q，data）
操作前提：队列Q已经存在。
操作结果：在队列Q的队尾插入data。
出队操作：DeleteQueue（Q，&data）
操作前提：队列Q已经存在且非空。
操作结果：将队列Q的队头元素出队，并使用data带回出队元素的值。
取队首元素：GetHead（Q，&data）
操作前提：队列Q已经存在且非空。
操作结果：若队列为空则返回1，否则返回0。
清空队列：ClearQueue(&Q)
操作前提：队列Q已经存在。
操作结果：将Q置为空队列。
- 队列的顺序存储结构之循环队列
队列的顺序存储有很大的缺陷，会造成大量的已出队的元素的存储空间浪费。而且，若此时入队元素已经大于n，则我们需要更大的存储空间才行，但队头位置有大量空间未利用，空间浪费严重。
解决以上问题的方法就是如果后面满了，则我们就从头开始，也就是将队列做成头尾相接的循环。我们把这种头尾相接的顺序存储结构的队列称为循环队列。
循环队列的结构定义：
typedef int DataType; //队列中元素类型
typedef struct Queue
{
DataType Queue[MaxSize];
int fornt; //队头指针
int rear; //队尾指针
}SeqQueue;
- 循环队列的基本操作
1.初始化队列：InitQueue（Q）
//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue *SQ)
{
SQ->fornt = SQ->rear = 0; //把对头和队尾指针同时置0
}
2.判断队列是否为空：IsEmpty（Q）
//判断队列为空
int IsEmpty(SeqQueue* SQ)
{
if (SQ->fornt == SQ->rear)
{
return 1;
}
return 0;
}
3.判断队列是否已满：IsFull（Q）
//判断队列是否为满
int IsFull(SeqCirQueue* SCQ)
{
//尾指针+1追上队头指针，标志队列已经满了
if ((SCQ->rear + 1) % MaxSize == SCQ->fornt)
{
return 1;
}
return 0;
}
4.入队操作：EnterQueue（Q，data）
int EnterSeqCirQueue(SeqCirQueue* SCQ, DataType data)
{
if (IsFull(SCQ))
{
printf("队列已满，不能入队！\n");
return 0;
}
SCQ->Queue[SCQ->rear] = data;
SCQ->rear = (SCQ->rear + 1) % MaxSize; //重新设置队尾指针
}
5.出队操作：DeleteQueue（Q，&data）
int DeleteSeqCirQueue(SeqCirQueue* SCQ,DataType* data)
{
if (IsEmpty(SCQ))
{
printf("队列为空！\n");
return 0;
}
*data = SCQ->Queue[SCQ->fornt];
SCQ->fornt = (SCQ->fornt + 1) % MaxSize; //重新设置队头指针
}
6.取队首元素：GetHead（Q，&data）
int GetHead(SeqCirQueue* SCQ,DataType* data)
{
if (IsEmpty(SCQ))
{
printf("队列为空！\n");
return 0;
}
*data = SCQ->Queue[SCQ->fornt];
return *data;
}
7.清空队列：ClearQueue(&Q)
void ClearSeqCirQueue(SeqCirQueue* SCQ)
{
SCQ->fornt = SCQ->rear = 0;
}
- 队列的链式存储结构
队列的链式存储结构简称为链式队列，它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。链队的操作实际上是单链表的操作，只不过是出队在表头进行，入队在表尾进行。入队、出队时分别修改不同的指针。
链式队列的结点是动态开辟的，入队时，为新节点开辟空间，出队使释放出队元素结点的空间。所以相对于顺序队列和循环队列，链式队列没有判断队列是否为满操作。但在清空队列时需要将队列所有结点的空间动态释放，从而防止内存泄露。
链式队列的结构定义：
typedef int DataType;
typedef struct Node
{
DataType _data;
struct Node* _next;
}LinkQueueNode;
typedef struct
{
LinkQueueNode* front;
LinkQueueNode* rear;
}LinkQueue;
- 链式队列的操作
1.初始化队列
//初始化队列
void InitLinkQueue(LinkQueue* LQ)
{
//创建一个头结点
LinkQueueNode* pHead = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
assert(pHead);
LQ->front = LQ->rear = pHead; //队头和队尾指向头结点
LQ->front->_next = NULL;
}
2.判断队列是否为空
//判断队列是否为空
int IsEmpty(LinkQueue* LQ)
{
if (LQ->front->_next == NULL)
{
return 1;
}
return 0;
}
3.入队
//入队操作
void EnterLinkQueue(LinkQueue* LQ, DataType data)
{
//创建一个新结点
LinkQueueNode* pNewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
assert(pNewNode);
pNewNode->_data = data; //将数据元素赋值给结点的数据域
pNewNode->_next = NULL; //将结点的指针域置空
LQ->rear->_next = pNewNode; //将原来队列的队尾指针指向新结点
LQ->rear = pNewNode; //将队尾指针指向新结点
}
4.出队
//出队操作
void DeleteLinkQueue(LinkQueue* LQ,DataType* data)
{
if (IsEmpty(LQ))
{
printf("队列为空！\n");
return;
}
//pDel指向队头元素，由于队头指针front指向头结点，所以pDel指向头结点的下一个结点
LinkQueueNode* pDel = LQ->front->_next;
*data = pDel->_data; //将要出队的元素赋给data
LQ->front->_next = pDel->_next; //使指向头结点的指针指向pDel的下一个结点
//如果队列中只有一个元素,将队列置空
if (LQ->rear = pDel)
{
LQ->rear = LQ->front;
}
free(pDel); //释放pDel指向的空间
}
5.取队头元素
//取队头元素
int GetHead(LinkQueue* LQ, DataType* data)
{
if (IsEmpty(LQ))
{
printf("队列为空!\n");
return 0;
}
LinkQueueNode* pCur;
pCur = LQ->front->_next; //pCur指向队列的第一个元素，即头结点的下一个结点
*data = pCur->_data; //将队头元素值赋给data
return *data; //返回队头元素值
}
6.清空队列
//清空队列
void ClearQueue(LinkQueue* LQ)
{
while (LQ->front != NULL)
{
LQ->rear = LQ->front->_next; //队尾指针指向队头指针的下一个结点
free(LQ->front); //释放队头指针指向的结点
LQ->front = LQ->rear; //队头指针指向队尾指针
}
}
- 队列应用：报数游戏
题干：报数游戏是这样的：有n个人围成一圈，按顺序从1到n编好号。从第一个人开始报数，报到m（m<n）的人退出圈子；下一个人从1开始报数，报到m的人退出圈子。如此下去，直到留下最后一个人。其中n是初始人数；m是游戏规定的退出位次（保证为小于n的正整数）。
分析：使用队列可以很好的模拟报数游戏，如果报数为m那么退出队列，否则重新进入队列，重复此过程直至队列为空，即所有人都退出圈子
解题思路（以伪代码的形式呈现）：
输入队列
while 队列中有元素
出队
if 报数为m then 输出该元素
else 入队
end if
end while
具体实现代码如下：
#include <iostream>
#include <string>
#include <queue>
using namespace std;
void CountGame(queue<int> qu, int m, int n);
int main()
{
queue<int> qu;
int n;
int m;
int i;
cin >> n >> m;
for (i = 1;i <= n;i++)
{
qu.push(i);
}
CountGame(qu, m, n);
return 0;
}
void CountGame(queue<int> qu, int m, int n)
{
if (m >= n)
{
cout << "error!";
return;
}
int temp;
int num = 0;
int flag = 1;
while (!qu.empty())
{
temp = qu.front();
qu.pop();
num++;
if (num == m)
{
if (flag)
{
cout << temp;
flag = 0;
}
else cout << " " << temp;
num = 0;
}
else qu.push(temp);
}
}
关于顺序存储和链式存储的选择，总体来说
- 若可以大致确定元素个数的情况下，推荐使用顺序存储
- 若无法事先预知元素个数，则应使用链式存储
1.2.谈谈你对栈和队列的认识及学习体会
- 对栈和队列的认识
栈是限定仅在表尾进行插入和删除操作的线性表，是一种具有后进先出的数据结构，又称为后进先出的线性表，也就是说后存放的先取，先存放的后取，这就类似于我们要在取放在箱子底部的东西（放进去比较早的物体），我们首先要移开压在它上面的物体（放进去比较晚的物体）。
队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。和栈一样，队列是一种操作受限制的线性表。队列是一种先进先出的数据结构，又称为先进先出的线性表,也就是说先放的先取，后放的后取，就如同行李过安检的时候，先放进去的行李在另一端总是先出来，后放入的行李会在最后面出来。 - 学习体会
最近学习了栈和队列的知识，从最初的看到就懵逼到现在对它们有一个清晰的认识，并能够进行简单的应用，就说明还是学到了一点东西。栈和队列这两种数据结构可以很轻易地解决某些特定的问题，也难怪老师说选对了数据结构，题目就解决了一半多。好好学习，天天向上！
2.PTA实验作业
2.1 表达式转换
2.1.1 代码截图
2.1.2 本题PTA提交列表说明
-
PTA提交列表
-
说明
| 错误 | 解决办法 |
|---|---|
| 多种错误 | 将运算符栈为空的情况单独考虑，并修正输出格式 |
2.2 符号配对
2.2.1 代码截图
2.2.2 本题PTA提交列表说明
-
PTA提交列表
-
说明
| 错误 | 解决办法 |
|---|---|
| Map容器转化反了 | 将右符号转化成左符号 |
| /*可能是乘除号 | 限制/后是或者后是/才是符号 |
| 开头多余左符号没有判断 | 最后判断栈是否空，空则配对，不空则右符号不匹配 |
3.阅读代码
3.1 题目及解题代码
题干：
题解：
3.1.1 该题的设计思路
设计思路：将数字直接放入栈内，遇到其他字符转化为对应的数字存入栈内，最后将栈内的数字一一取出相加就是得分的总和
时间复杂度：O(n)。需要遍历一次字符数组，遍历一次栈。
空间复杂度：O(n)。分配空间给了int型的index和res，以及一个栈。
3.1.2 该题的伪代码
for 遍历字符串
if 是"C" then 出栈
else
if 是"+" then tmp=栈内头两个数相加
else if 是"D" then tmp=栈顶*2
else tmp=得分
入栈tmp
end if
end if
for 出栈所有元素
累加到res中
end for
返回res
3.1.3 运行结果
3.1.4分析该题目解题优势及难点
-
解题优势
- 使用vector容器，就不用再考虑需要多少空间
- 将对应的操作字符转化为数字，统一了数据类型
- 使用for+auto遍历栈方便快捷
-
难点：
- 如何将操作字符转化为对应的数据
3.2 题目及解题代码
题干：
题解：
3.2.1 该题的设计思路
设计思路：
- 先排身高更高的，这是要防止后排入人员影响先排入人员位置
- 每次排入新人员[h,k]时，已处于队列的人身高都>=h，所以新排入位置就是people[k]
时间复杂度：O(n)。sort排序一次，for循环遍历list，重建vector容器
空间复杂度：O(n)。新建list存放people中的数据，重建vector存放排序好的数据
3.2.2 该题的伪代码
将people按照身高降序排序
相同身高需要按k升序排序
新建list容器tmp临时存放people中的数据
for 遍历tmp
寻找并将数据插入对应位置
end for
返回 根据tmp新建的vector容器
3.2.3 运行结果
3.1.4分析该题目解题优势及难点
- 解题优势：
- 使用sort函数，并重载比较函数，很方便的按照所需将数据排序好
- 使用list容器进行插入操作，代码的执行效率更高
- 难点
- 如何在存在k限制的情况下将身高排序好
