数据结构复习笔记（ADT栈/LIFO表）

栈是一种特殊的表，只在表首进行插入和删除操作，表首称之为栈顶，表尾称为栈底；栈的核心原则是先进后出，简称Last In First Out(LIFO表)；常用的运算有：1、是否为空栈判断；2、栈是否满判断；3、返回栈顶元素；4、插入栈顶元素；5、删除栈顶元素；

## 用数组实现栈代码：

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<malloc.h>
typedef struct astack *Stack;
typedef struct astack
{
int top;
int maxtop;
int *data;                //栈元素数组，可以是int型也可以是其他数据类型比如char；
}Astack;
Stack StackInit(int size,Stack S)
{
S->data=(int*)malloc(size*sizeof(int));
S->maxtop=size;
S->top=-1;                 //当top为1的时候，代表栈为空；
return S;
}
int StackEmpty(Stack S)
{
return S->top<0;
}
int StackFull(Stack S)
{
return S->top>=S->maxtop;                //当top=maxtop时，代表当前栈满
}
int StackTop(Stack S)
{
return S->data[S->top];                  //默认认为用户在使用栈时，需要考虑栈为空时无法返回栈顶元素
}
void Push(int x, Stack S)
{
S->top++;
S->data[S->top]=x;                        //默认用户所使用的栈空间(即在最开始用户开栈时需要提前考虑数组data大小)够大；
}
int Pop(Stack S)
{
S->top--;
return S->data[S->top];                   //默认此时栈不为空，否则是非法操作；
}
int main()
{
int i,j,n;
scanf("%d",&n);
Stack S=new Astack;
StackInit(n,S);
Push(0,S);
Push(5,S);
printf("%d",StackTop(S));
//  printf("%d",Pop(S));
Pop(S);
Push(2,S);
while(StackEmpty(S)!=1)                   //当栈不是空的时候，返回0，是空栈返回1；
{
printf("%d",StackTop(S));
Pop(S);
}
return 0;
}

栈的指针实现代码：

#include<cstdio>
#include<cstdlib>
#include<malloc.h>
typedef struct node* link;
typedef struct node                                 //自定义栈内节点数据类型 ；
{
int element;
link next;
}Node;
typedef struct astack* Stack;
typedef struct astack                               //定一个栈指针，有一个top顶点指针；
{
link top;
}Astack;

Stack StackInit(Stack S)
{
S->top=0;
return S;
}
int StackEmpty(Stack S)                            //判断top指针是不是空指针；
{
return S->top==0;
}
int StackFull(Stack S)                                 //通过指针实现的栈每次都是直接新开辟一个节点指针，所以只是看这个指针是否开辟成功；
{
link p=(node*)malloc(sizeof(Node));
if(p==NULL)return 1;
else
{
free(p);
return 0;
}
}
int StackTop(Stack S)
{
return S->top->element;
}
void Push(int x,Stack S)                              //直接插入x；
{
link p;
p=new Node;
p->element=x;
p->next=S->top;
S->top=p;
}
int Pop(Stack S)                                     //每次删除的元素都能够输出此时删除的元素是哪一个；
{
link p;
int x;
x=S->top->element;
p=S->top;
S->top=p->next;
free(p);
return x;
}
int main()
{
int i,j,n;
Stack S=new Astack;
StackInit(S);
//  link p=new Node;
Push(0,S);
Push(5,S);
printf("%d",Pop(S));
Push(2,S);
while(StackEmpty(S)!=1)
{
printf("%d",StackTop(S));
Pop(S);
}
return 0;
}

上面描述的都是通过自定义实现的栈的使用，其实还有直接可以使用的STL中的栈（即已经有直接可以使用的栈，比较方便，需要包括头文件stack）;

STL中的栈的使用简单介绍使用代码：

#include<cstdio>
#include<cstdlib>
#include<malloc.h>
#include<stack>                               //使用STL中已有的栈需要包括该文件
#include<iostream>
using namespace std;
stack<int>s;
int main()
{
int i,j,n;
scanf("%d",&n);
for(i=1;i<=n;i++)
{
s.push(i);                            //将1~n的数字存储到栈中，直接使用s.push(元素)；
}
if(s.empty()!=1)                          //如果栈空，则s.empty()返回1，否则返回0；
{
printf("Stack is not empty!\n");
s.pop();                              //此时如果使用s.pop()函数不能同时输出其删除元素，可先使用s.top()得到之后再删除；
}
else
{
printf("Stack is empty!\n");
}
while(s.empty()!=1)
{
printf("%d",s.top());
s.pop();
}
return 0;
}

第三次作业：

1、（栈的基本运算操作：入栈出栈等）：可以直接使用STL中的栈（比较懒就这样使用），也可以自定义栈实现（耗时当然比较少）；对于题目中的字符串代表不同操作，可以直接针对其首字母处理，会方便一点；

2、（栈的应用：计算中缀表达式结果，包含括号等操作符比如计算{3*（6+9/3-4）+8}的结果)：大致思路是使用两个栈，一个存储操作数，一个存储操作符，自定义操作符的优先级处理函数，然后对输入的表达式入栈、判断是否需要出栈、运算等操作；

题目实现代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<stack>

using namespace std;

stack<int> Num_Stk;
stack<char>Oper_Stk;

int Oper_Big(char ch)
{

if (Oper_Stk.empty() || ch == '(' || (Oper_Stk.top() == '('&&ch != ')'))
{
return 0;
}
else if ((Oper_Stk.top() == '+' || Oper_Stk.top() == '-') && (ch == '*' || ch == '/'))
{
return 0;
}
else if (Oper_Stk.top() == '('&&ch == ')')
{
Oper_Stk.pop(); return 1;
}
else return -1;
}

void Deal_num()
{
int num1 = Num_Stk.top(); Num_Stk.pop();
int num2 = Num_Stk.top(); Num_Stk.pop();
int ans = 0;
if (Oper_Stk.top() == '+')  ans = num1 + num2;
else if (Oper_Stk.top() == '-') ans = num2 - num1;
else if (Oper_Stk.top() == '*') ans = num1*num2;
else if (Oper_Stk.top() == '/')ans = num2 / num1;
Num_Stk.push(ans);
Oper_Stk.pop();

}

int main()
{
int num = 0;
char str[1000] = "";
cin >> str;
int i = 0, j = 0, k = 0;
while (str[i] != '\0')
{
char expre[1005]; j = 0;
while (str[i] >= '0'&&str[i] <= '9')
{
expre[j] = str[i]; i++;
j++; expre[j] = '\0';
}
if (str[i] != '(')
{
num = atoi(expre);
Num_Stk.push(num);
}
while (1)
{
k = Oper_Big(str[i]);
if (k == 0)
{
Oper_Stk.push(str[i]);
break;
}
else if (k == 1)
{
i++;
}
else if (k == -1)
{
Deal_num();
}
}
i++;
}
cout << Num_Stk.top() << endl;
return 0;
}