数据结构笔记||栈

定义

栈是一种只能在一端进行插入或删除操作的线性表

特点：后进先出

顺序栈

顺序栈s初始时设置s->top=-1，s的4要素

• 栈空的条件：s->top==-1
• 栈满的条件：s->top==MaxSize-1(data数组的最大下标)
• 元素e的进栈操作：先将栈顶指针top增1，然后将元素e放在栈顶指针处
• 出栈操作：先将栈顶指针top处的元素取出放在e中，然后将栈顶指针减1

算法如下

#include<iostream>
#include<cstdlib>
using namespace std;
#define MaxSize 100
typedef char ElemType;
typedef struct
{
	ElemType data[MaxSize];
	int top;
}SqStack;

//初始化栈：创建一个空栈，由s指向它，栈顶指针设为-1 
void InitStack(SqStack *&s)
{
	s=(SqStack *)malloc(sizeof(SqStack)); //分配一个顺序栈空间，首地址存放在s中 
	s->top=-1;                           //栈顶指针置为-1 
}

//销毁栈：释放顺序栈s占用的存储空间 
void DestroyStack(SqStack *&s)
{
	free(s);
}

//判断栈是否为空：实际上用于判断条件s->top==-1是否成立 
bool StackEmpty(SqStack *s)
{
	return(s->top==-1); 
}

//进栈：在栈不满的条件下先将栈顶指针增1，然后在该位置上插入元素e，并返回真；否则返回假。 
bool Push(SqStack *&s,ElemType e)
{
	if(s->top==MaxSize-1)       //栈满的情况，即栈上溢出 
	   return false;
	s->top++;                  //栈顶指针增1 
	s->data[s->top]=e;         //元素e放在栈顶指针处 
	return true;
}

//出栈：在栈不为空的条件下先将栈顶元素赋给e，然后将栈顶指针减1，并返回真；否则返回假。 
bool Pop(SqStack *&s,ElemType &e)
{
	if(s->top==-1)             //栈为空的情况下，即栈下溢出 
	  return false;
	e=s->data[s->top];        //取栈顶元素 
	s->top--;                 //栈顶指针减1 
	return true;
}

//取栈顶元素：在栈不为空的条件下将栈顶元素赋给e并返回真；否则返回假。 
bool GetTop(SqStack *s,ElemType &e)
{
	if(s->top==-1)            //栈为空的情况下，即栈下溢出
	  return false;
	e=s->data[s->top];       //取栈顶元素
	return true;
} 

链栈

链栈s的4要素

• 栈空的条件：s->next==NULL
• 栈满的条件：由于只有内存溢出时才出现栈满，通常不考虑这样的情况，所以在链栈中可以看出不存在栈满
• 元素e的进栈操作：新建一个结点存放元素e（由p指向它），将结点p插入到头结点之后
• 出栈操作：取出首结点的data值并将其删除

算法如下：

#include<iostream>
#include<cstdlib>
using namespace std;
typedef char ElemType;
typedef struct linknode
{
	ElemType data;
	struct linknode *next;
}LinkStNode;

//初始化栈：创建空链栈s，实际是创建链栈的头结点，将其next域置为NULL 
void InitStack(LinkStNode *&s)
{
	s=(LinkStNode *)malloc(sizeof(LinkStNode));
	s->next=NULL;
}

//销毁栈：释放链栈s占用的全部结点空间 
void DestroyStack(LinkStNode *&s)
{
	LinkStNode *pre=s,*p=s->next;  //pre指向头结点，p指向首结点 
	while(p!=NULL)                //循环到p为空 
 	{
		free(pre);               //释放pre结点 
		pre=p;                   //pre、p同步后移 
		p=pre->next;
	}
	free(pre);                  //此时pre指向尾结点，释放其空间 
}

//判断栈是否为空：判断s->next=NULL的条件是否成立 
bool StackEmpty(LinkStNode *s)
{
	return(s->next==NULL);
}

//进栈：新建一个结点，用于存放元素e（由p指向它），然后将其插入到头结点之后作为新的首结点 
void Push(LinkStNode *&s,ElemType e)
{
	LinkStNode *p;
	p=(LinkStNode *)malloc(sizeof(LinkStNode));  //新建结点p 
	p->data=e;                                  //存放元素e 
	p->next=s->next;                            //将p结点插入作为首结点 
	s->next=p;
}

//出栈：在栈不为空的条件下提取首结点的数据域赋给引用型参数e，然后将其删除 
bool Pop(LinkStNode *&s,ElemType &e)
{
	LinkStNode *p;
	if(s->next==NULL)             //栈空的情况 
	   return false;             //返回假 
	p=s->next;                  //p指向首结点 
	e=p->data;                 //提取首结点值 
	s->next=p->next;          //删除首结点 
	free(p);                 //释放被删结点的存储空间 
	return true;             //返回真 
}