栈——顺序栈和链栈的定义和基本操作

顺序存储方式实现栈代码（以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;
}

代码运行结果