顺序栈与链栈

  从逻辑关系上来看，栈属于线性结构，与线性表的不同之处在于一般线性表的插入，删除运算不受限制，而栈插入，删除运算均受某种特殊限制，可称为受限的线性表。

  栈的特点：

               后进先出

顺序栈:

  栈空的条件: s->top == -1;

  栈满的条件:s->top == MaxSize-1 (其中MaxSize为data数组的最大下标)

  元素e的进栈操作: 先将栈顶指针top加1，然后将元素e放在栈顶指针处

  出栈操作类比进栈

基本操作及实现：

#include<bits/stdc++.h>
#define MaxSize 100
typedef int ElemType;
using namespace std;
typedef struct
{
	ElemType data[MaxSize];
	int top;
}SqStack;

void InitStack(SqStack *&s)  //初始化栈 
{
	s=(SqStack *)malloc(sizeof(SqStack));
	s->top=-1;
}

void DestroyStack(SqStack *&s) //销毁栈 
{
	free(s);
}

bool StackEmpty(SqStack *s) //判断栈是否为空 
{
	return(s->top==-1);
}

bool Push(SqStack *&s,ElemType e) //进栈 
{
	if(s->top==MaxSize-1) //判断 是否 栈上溢出 
	{
		return false;
	}
	s->top++;
	s->data[s->top]=e;
	return true;
}

bool Pop(SqStack *&s,ElemType &e) //出栈 
{
	if(s->top==-1)  // 判断 是否 栈下溢出 
	{
		return false;
	}
	e=s->data[s->top];
	s->top--;
	return true;
}

bool GetTop(SqStack *s, ElemType &e) //取栈顶元素 
{
	if(s->top==-1)
	{
		return false;
	}
	e=s->data[s->top];
	return true;
}

int main()
{
	SqStack *s;
	int e;
	InitStack(s);
	int a[6]={1,2,3,4,5,6};
	for (int i=0;i<6;i++)
	{
		Push(s,a[i]);
	}
	while(!StackEmpty(s))
	{
		Pop(s,e);
		cout<<e<<" ";
	}
	return 0;
}

程序测试的结果为 6 5 4 3 2 1 

由此可知 按123456的顺序入栈 后 中间不进行出栈操作 再将栈顶元素一个个出栈得到的是原来字符串的逆序排列

则引申出一个简单的应用

判断一个字符串是否为对称串:

bool symmetry(ElemType str[])
{
	int i;ElemType e;
	SqStack *st;
	InitStack (st);
	for (i=0;str[i]!='\0';i++)
	{
		Push(st,str[i]);  //将str中的所有元素进栈 
	}
	for (i=0;str[i]!='\0';i++)
	{
		Pop(st,e);      // 出栈元素e 
		if(str[i]!=e)  //判断 是否为对称栈 
		{
			Destroy(st);
			return false;
		}
	}
	Destroy(st);
	return true;
}

链栈:

  栈空的条件:s->next==NULL;

  栈满的条件：只有内存溢出时才出现栈满，通常不考虑这样的情况，因为在这可以认为栈不会满

  元素e的进栈操作: 新建一个结点存放元素e(由p指向它),然后将p结点插入到头节点之后

  出栈操作:取出首节点的data并删除该节点

#include<bits/stdc++.h>
using namespace std;
typedef struct linknode
{
	ElemType data;
	struct linknode * next;
}LinkStNode;

void InitStack(LinkStNode *&s)
{
	s=(LinkStNode *)malloc(sizeof(LinkStNode));
	s->next=NULL;
}

void DestroyStack(LinkStNode *&s) // 同单链表删除结点的操作 
{
	LinkStNode *pre=s,*p=pre->next;
	while(p!=NULL)
	{
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}

bool StackEmpty(LinkStNode *s)
{
	return (s->next==NULL);
 } 
 
void Push(LinkStNode *&s,ElemType e)
{
	LinkStNode *p;
	p=(LinkStNode *)malloc(sizeof(LinkStNode));
	p->data=e;
	p->next=s->next;
	s->next=p;
}

bool Pop(LinkStNode *&s,ElemType &e)
{
	if(s->next==NULL) //判断链栈是否为空 
	{
		return false;
	}
	LinkStNode *p=s->next;
	s->next=p->next;
	e=p->data;
	free(p);
	return true;
}

bool GetTop(LinkStNode *&s,ElemType &e)
{
	if(s->next==NULL)
	{
		return false;
	}
	e=s->next->data;
	return true;
}

参考自李春葆数据结构第五版