数据结构-顺序栈、共享栈和链栈的实现

最新推荐文章于 2024-06-30 20:22:15 发布

yaoyao_ju

最新推荐文章于 2024-06-30 20:22:15 发布

阅读量457

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/yaoyao_ju/article/details/124222026

版权

1、顺序栈的实现代码分为以下两种情况：

1）top=-1

2）top=0

1）top=-1 具体实现代码如下：

//情况一-----若栈顶元素为-1 
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
typedef int ElemType;

//定义顺序栈的结构 
typedef struct{
	ElemType data[MaxSize] ;
	int top;
}SqStack;

//初始化栈 
void InitStack(SqStack &S){
	S.top=-1;
} 
//判断栈是否为空
bool StackEmpty(SqStack S){
	if(S.top==-1){
		printf("栈为空！") ;
		return true;
	}else{
		return false;
	}
}
 
//进栈
bool Push(SqStack &S,ElemType value){
	if(S.top==MaxSize-1){	//判断栈满 
		return false;
	}
//	S.top=S.top+1;     //栈顶指针往上移动一位 
//	S.data[S.top]=value;   //value入栈 
	S.data[++S.top]=value;  //这一句话可以代替上面两句 
	return true;
} 

//出栈 
bool Pop(SqStack &S,ElemType &value){
	StackEmpty(S) ;//判断栈是否为空 
//	value=S.data[S.top];  //把栈顶元素的值赋给value 
//	S.top=S.top--;  //栈顶指针下移，表示栈顶元素出栈 
	value=S.data[S.top--];  //这一句可以代替上面两句 
	return true;
} 

//读取栈顶元素
bool GetTop(SqStack S,ElemType &value){
	StackEmpty(S) ;//判断栈是否为空 
	value=S.data[S.top];
	printf("栈顶元素为：%d\n",value);
	return true;
} 
int main(){
	SqStack S;
	InitStack(S);
	//StackEmpty(S);
	ElemType value;
	for(int i=0;i<MaxSize;i++){	//入栈 
		Push(S,i+1);
	}
	for(int i=0;i<MaxSize;i++){	 
		GetTop(S,value);	//获取栈顶元素 
		Pop(S,value);		//出栈 
	}
	

}

2)top=0 具体实现代码如下：

//情况二-----若栈顶元素为0 
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10
typedef int ElemType;

//定义栈的结构 
typedef struct{
	ElemType data[MaxSize] ;
	int top;
}SqStack;

//初始化栈 
void InitStack(SqStack &S){
	S.top=0;
} 

//判断栈是否为空
bool StackEmpty(SqStack S){
	if(S.top==0){
		printf("栈为空！\n") ;
		return true;
	}else{
		return false;
	}
} 

//进栈
bool Push(SqStack &S,ElemType value){
	if(S.top==MaxSize){	//判断栈满 
		printf("栈已满\n");
		return false;
	}
	
	S.data[S.top]=value;   //入栈 
	S.top=S.top+1;     //栈顶指针往上移动一位 
//	S.data[S.top++]=value;  //这一句话可以代替上面两句 
	return true;
} 

//出栈 
bool Pop(SqStack &S,ElemType &value){
	StackEmpty(S);	//判断栈是否为空  
	S.top=S.top-1;  //栈顶指针下移，表示栈顶元素出栈 
	value=S.data[S.top];  //把栈顶元素的值赋给value 
//	value=S.data[--S.top];  //这一句可以代替上面两句 
	return true;
} 

//读取栈顶元素--注意栈顶指针减一才可查询到最上面元素 
bool GetTop(SqStack S,ElemType &value){
	StackEmpty(S);//判断栈是否为空 
	value=S.data[S.top-1]; //栈顶指针下移 
	printf("栈顶元素为：%d  \n",value);
	return true;
} 

int main(){
	SqStack S;	//定义一个栈 
	InitStack(S);	//初始化栈S 
	StackEmpty(S);	//判断栈是否为空 
	ElemType value;
	for(int i=0;i<MaxSize;i++){	//入栈 
		Push(S,i+1);
	}
	for(int i=0;i<MaxSize;i++){	
		GetTop(S,value);	//获取栈顶元素 
		Pop(S,value);	//出栈 
	}
}

2、共享栈的实现

#include <stdio.h> 
#include <stdlib.h>


//共享栈的实现------顺序栈 
#define MaxSize 10
typedef int ElemType;

//共享栈的结构定义
typedef struct {
	ElemType data[MaxSize];//静态数组存放栈元素 
	int top0; //0号栈栈顶指针 
	int top1;  //1号栈栈顶指针 
}ShStack;
//栈的初始化
bool InitShStack(ShStack &S){
	S.top0=-1;
	S.top1=MaxSize;
	return true;
} 
//判断栈是否为空
bool StackEmpty(ShStack S,int flag){
	//判断栈是否为空 
	if(flag==0&&S.top0==-1){
		printf("0号栈为空！\n");
		return true; 
	}else if(flag==1&&S.top1==MaxSize){
		printf("1号栈已空！\n");
		return true;
	}
}

//0,1号栈入栈 
bool Push(ShStack &S,ElemType x,int flag) {
	//判断栈是否已满
	if(S.top0+1==S.top1){
		printf("该栈全部已满，不能继续插入栈元素！\n");
		return false;
	} 
	
	if(flag==0){//flag=0时为0号栈入栈 
		
	//	S.top0=S.top0+1;     //0号栈指针＋1指向0 
	//	S.data[S.top0]=x;   //x进入0栈 
	    S.data[++S.top0]=x;  //上面两句可以合并为这一句 
		return true;
	}else if(flag==1)			//flag=1时表示1号栈入栈 
	{
//		S.top1=S.top1-1;		//top1由10指向9 
//		S.data[S.top1] =x;		//x进入1号栈 
		S.data[--S.top1]=x;		//上面两句可以合并该句 
		return true;
	}else {
		
		printf("输入有误！\n");
	}
}

//0、1栈出栈
bool Pop(ShStack &S,ElemType &x,int flag){
	StackEmpty(S,flag);
	//出栈，先赋值再减1 
	if(flag==0){	//flag=0,0号栈出栈 
	//先赋值，在减1 
//		S.data[S.top0]=x;
//		S.top0=S.top0-1;
		S.data[S.top0--]=x;
		printf("0号栈移除的元素为：%d\n",x);
		 
	}else if(flag==1){	//flag=1，1号栈出栈 
	//先赋值，再加1 
//		S.data[S.top1]=x;
//		S.top1=S.top1+1
		S.data[S.top1++]=x;
		printf("1号栈移除的元素为：%d\n",x);
	} else{
		printf("flag输入有误！\n");
	}
	return true;
}
//读取栈顶元素 
bool GetTop(ShStack S,ElemType &x,int flag){
	StackEmpty(S,flag);
	if(flag==0){	//flag=0,读取0号栈栈顶元素 
		x=S.data[S.top0]; 
		printf("0号栈栈顶元素为 %d\n",x);
	} else if(flag==1){
		x=S.data[S.top1];
		printf("1号栈栈顶元素为 %d\n",x);
	} else{
		printf("输入有误！\n");
	}		
} 

int main(){
	ShStack S;
	InitShStack(S);
	ElemType x;
	for(int i=0;i<5;i++){
		Push(S,i+1,0);//0号栈入栈 
		Push(S,MaxSize-i,1);//1号栈入栈 
	}
	for(int i=0;i<5;i++){
		
		GetTop(S,x,0);//获取0号栈栈顶元素 
		Pop(S,x,0);   //移除0号栈栈顶元素 
		
		GetTop(S,x,1);//获取1号栈栈顶元素 
		Pop(S,x,1);   //移除1号栈栈顶元素
	}
		
}

3.链栈的实现（分为带头结点和不带头结点）

(1)带头结点的链栈的基本操作：

/*
 * 带头结点的链式存储栈的基本操作。
*/

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <cstdio>

typedef int ElemType;

 /*
 **进栈、出栈都在头结点一侧进行。
 **由于带有头结点，可不设置栈顶指针，头结点可视为栈顶指针来进行操作。
 */
 
//栈的链式存储结构定义 
typedef struct StackNode{
	ElemType data;			//数据域 
	struct StackNode *next;	//指针域 
}StackNode,*LinkStack; 

//栈的初始化 
bool InitLinkStack(LinkStack &S){
	S=(StackNode *)malloc(sizeof(StackNode));	//定义头结点 
	if(S!=NULL){
		S->data=-1;	//头结点数据域初始化为-1 
		S->next=NULL; //头指针的指针域赋空 
	}else{
		printf("申请内存空间失败\n");
	}
	return true;
}

//判断栈是否为空
bool Empty_LinkStack(LinkStack S){
	if(S->next==NULL){	
		printf("该链栈为空栈\n");
		return true; 
	}else{
		return false;
	}
}
//进栈操作(只在头结点进栈操作)
bool Push_LinkStack(LinkStack &S,ElemType value){
	
	StackNode *NewNode=(StackNode *)malloc(sizeof(StackNode));	//创建新结点 
	if(NewNode==NULL){		//判断结点是否申请内存成功 
		printf("申请内存空间失败\n");
		return false;
	}else{
		NewNode->data=value;	//把value赋给newnode结点
		NewNode->next=S->next;  //头结点指针指向新插入的结点 
		S->next=NewNode;	//修改栈顶指针,使S移动到p 
		return true;
	}
	
}

 // 出栈操作(只在头结点出栈操作)
bool Pop_LinkStack(LinkStack &S,ElemType &value){
	StackNode *delNode;//定义新结点	
	delNode=S->next;	//出栈的结点 
	if(Empty_LinkStack(S)){ //判断栈空 
		return false;
	}
	value=delNode->data;	//出栈结点的数据域赋值value 
	S->next=delNode->next; //头结点指针域指向出栈结点的后一位 
	free(delNode);		//删除结点 
	return true;
	
}

// 获取栈顶元素
ElemType getTop(LinkStack S){
	
    Empty_LinkStack(S);	//判空 
    return S->next->data; //获取栈顶元素 
} 
//创建一个链栈
bool createLinkStack(LinkStack &S){
	ElemType x;  //定义x接收进栈元素 
	printf("请输入进栈元素：(输入9999结束！)\n");
	scanf("%d",&x); //输入进栈元素
	while(x!=9999){  //输入进栈元素，9999结束 
		Push_LinkStack(S,x);	//调用进栈函数 
		scanf("%d",&x);	//输入进栈元素
	} 
	return true;	
}
 
//栈的遍历
void printStack(LinkStack S){
	
	while(S != NULL){
        printf("栈里的值(包含头结点)- %d \n",S->data);
        S= S->next;
    }
}
 
int main(){
	LinkStack S;
	InitLinkStack(S);
	createLinkStack(S);
	printStack(S);
	printf("--------获取栈顶元素---------\n") ;
	ElemType top_value=getTop(S);
	printf("栈顶元素为：%d\n",top_value); 
	printf("--------出栈操作---------\n") ;
	Pop_LinkStack(S,top_value);
	printStack(S);
	
}

(2)带头结点的链栈的基本操作：

/*
 * 不带头结点的链式存储栈的基本操作。
*/

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <cstdio>

typedef int ElemType;

 
//栈的链式存储结构定义 
typedef struct StackNode{
	ElemType data;			//数据域 
	struct StackNode *next;	//指针域 
}StackNode,*LinkStack; 

//栈的初始化 
bool InitLinkStack(LinkStack &S){

	S=NULL; //赋空 
	return true;
}

//判断栈是否为空
bool Empty_LinkStack(LinkStack S){
	if(S==NULL){	
		printf("该链栈为空栈\n");
		return true; 
	}else{
		return false;
	}
}
//进栈操作（相当于单链表的后插操作） 
bool Push_LinkStack(LinkStack &S,ElemType value){
	
	StackNode *NewNode=(StackNode *)malloc(sizeof(StackNode));	//创建新结点 
	if(NewNode==NULL){		//判断结点是否申请内存成功 
		printf("申请内存空间失败\n");
		return false;
	}else{
		NewNode->data=value;	//把value赋给newnode结点
		NewNode->next=S;  // NewNode的next指针域置为空 
		S=NewNode;	//进栈 
		return true;
	}
	
}

 // 出栈操作（相当于单链表的后删操作） 
bool Pop_LinkStack(LinkStack &S,ElemType &value){
	StackNode *delNode;	//定义新结点	
	delNode=S;	//出栈的结点 
	if(Empty_LinkStack(S)){ 	//判断栈空 
		return false;
	}
	value=delNode->data;	//出栈结点的数据域赋值value 
	S=delNode->next;    // 改变栈顶 
	free(delNode);		//删除结点 
	return true;
	
}

// 获取栈顶元素
ElemType getTop(LinkStack S){
	
    Empty_LinkStack(S);	//判空 
    return S->data;   //获取栈顶元素 
} 
//创建一个链栈
bool createLinkStack(LinkStack &S){
	ElemType x;  //定义x接收进栈元素 
	printf("请输入进栈元素：(输入9999结束！)\n");
	scanf("%d",&x); //输入进栈元素
	while(x!=9999){  //输入进栈元素，9999结束 
		Push_LinkStack(S,x);	//调用进栈函数 
		scanf("%d",&x);	//输入进栈元素
	} 
	return true;	
}

 
//栈的遍历
void printStack(LinkStack S){
	
	while(S != NULL){
        printf("栈里的值: %d \n",S->data);
        S= S->next;
    }
}
 
int main(){
	LinkStack S;
	InitLinkStack(S);
	createLinkStack(S);
	printStack(S);
	printf("--------获取栈顶元素---------\n") ;
	ElemType top_value=getTop(S);
	printf("栈顶元素为：%d\n",top_value); 
	printf("--------出栈操作---------\n") ;
	Pop_LinkStack(S,top_value);
	printStack(S);
	
}