顺序存储方式实现栈代码（以s.top= -1为例）
#include<stdio.h>
#include<iostream>
#define Maxsize 10
typedef struct{
int data[Maxsize]; //静态数组存放栈中元素
int top; //栈顶指针 ，实际当做数组下标用
}SqStack; //栈的类型定义（结构体）
//基本操作，创销，增删改查，判空满 ，取栈顶元素
/* 方式一：让栈顶指针指向栈顶元素 栈顶指针初始值 S.top=-1*/
/* 方式二：让栈顶指针指向下一个可以插入的位置，即栈顶元素位置+1处 栈顶指针初始值 S.top=0 */
void InitStack(SqStack &S)
{
S.top=-1; //初始化栈顶指针
}
bool StackEmpty(SqStack S)
{
if(S.top==-1)
return true; //栈空
else
return false;
}
//入栈操作
bool Push(SqStack &S,int x)
{
if(S.top==Maxsize-1) //栈满，报错，top=0时放入第一个元素，因此注意是Maxsize-1
return false;
S.top=S.top+1; //指针先加一
S.data[S.top]=x; // 新元素入栈 这两句可简写为 S.data[++S.top]=x;
}
//出栈操作
bool Pop(SqStack &S, int &x)
{
if(S.top==-1) //栈空判断，报错
return false;
x=S.data[S.top]; //栈顶元素出栈
S.top=S.top-1; //指针减1 x=S.data[S.top--] 数据还残留在内存中，只是逻辑上删除了
return true;
}
//读栈顶元素
bool GetTop(SqStack &S,int &x)
{
if(S.top==-1) //栈空，报错
return false;
x=S.data[S.top]; // x记录栈顶元素
return true;
}
void Show(SqStack S)
{
for(int i=0;i<S.top+1;i++)
{
printf("%d ",S.data[i]);
}
printf("\nLength: %d\n",S.top+1);
}
int main()
{
SqStack S; //声明一个顺序栈（分配空间）
InitStack(S);
Push(S,1);
Push(S,2);
Push(S,3);
Push(S,4);
Push(S,5);
Show(S);
int x=0;
Pop(S,x);
int top;
GetTop(S,top);
printf("已将栈顶元素%d出栈,出栈后的栈顶元素为%d\n",x,top);
Show(S);
return 0;
}
代码运行结果
链式方式实现栈代码（相当单链表只在头结点插入与删除）
#include<stdio.h>
#include<cstdlib>
#include<iostream>
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkStack; //与单链表类似，在头结点处插入和删除等同于
bool InitList(LinkStack &L)
{
L=(LNode*)malloc(sizeof(LNode)); //分配一个头结点 ，并将malloc 返回的地址赋给L，即L是指向头结点
if(L==NULL)
return false;
L->next=NULL;
return true;
}
bool Empty(LinkStack L){
if(L->next==NULL)
return true;
else
return false;
}
//按位查找，返回第i个元素 平均时间复杂度 O(n)
LNode * GetElem(LinkStack L,int i) {
if(i<0) //边界情况处理
return NULL;
LNode *p; //指针p指向当前扫描到的结点
int j=0; //将头结点看成第0个结点
p=L; // L指向头结点，p指针当前指向头结点
while(p!=NULL&&j<i)
{ //循环找到第i个结点
p=p->next;
j++;
}
if(p==NULL)
return false;
return p;
}
//按值查找，找到数据值等于e的结点 平均时间复杂度 O(n)
LNode * LocateElem(LinkStack L ,int e)
{
LNode *p=L->next; //指向第一个含数据的结点
while(p!=NULL&&p->data!=e)
{
p=p->next;
}
return p;
}
//求表长 平均时间复杂度 O(n)
int Length(LinkStack L)
{
int len=0;
LNode *p=L;
while(p->next!=NULL)
{
p=p->next;
len++;
}
return len;
}
//入栈操作
bool Push(LinkStack &L,int e)//限制只能在头结点后插入(入栈）
{
LNode *s=(LNode *)malloc(sizeof(LNode));//申请一个新的结点空间
if(s==NULL) //内存分配失败
return false;
s->data=e; //用结点s保存数据元素e
s->next=L->next;
L->next=s; //将结点s连到p之后
return true;
}
//出栈操作
int Pop(LinkStack &L)//限制只能在头结点后删除(出栈）
{
int e;
if(Empty(L))
{
printf("栈空，出栈操作失败\n");
return false;
}
LNode *q=L->next;
e=q->data;
L->next=q->next;
free(q);
return e;
}
//读栈顶元素
int GetTop(LinkStack &L)
{
if(Empty(L)) //栈空，报错
{
printf("栈空，读栈顶元素失败\n");
return false;
}
return L->next->data;
}
void Show(LinkStack L)
{
LNode *p=L->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf("\nLength: %d\n",Length(L));
}
int main()
{
LinkStack L; //声明一个指向链栈的指针
InitList(L); //初始化
Push(L,1);
Push(L,2);
Push(L,3);
Push(L,4);
Push(L,5);
Show(L);
int e=Pop(L);
printf("已删除栈顶元素，删除元素值为 %d，删除后链表为：\n",e);
Show(L);
int t=GetTop(L);
printf("栈顶元素为: %d\n",t);
LNode *p1=GetElem(L,2);
printf("栈L中位置为2的元素为 %d\n",p1->data);
return 0;
}
代码运行结果
