ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

数据结构C/C++实现——栈之顺序栈(含共享顺序栈)

2021-12-29 21:30:53  阅读：236  来源： 互联网

标签：顺序 return SqStack ElemType top 栈顶 C++ 数据结构 data


top指向栈顶元素本身: 

/*
栈：只允许在一段进行插入或删除操作的线性表
顺序栈：用顺序存储方式实现的栈
*/
#include<cstdio>
#include<iostream>
using namespace std;

#define MaxSize 5                                 //定义顺序栈最大长度
#define ElemType int

typedef struct {
	ElemType data[MaxSize];                        //静态数组存放栈中元素
	int top;                                       //栈顶指针
}SqStack;                                          //顺序栈类型定义   sq:sequence顺序

//初始化顺序表
void InitStack(SqStack& S) {
	S.top = -1;
}

/*
此种设定下：
    栈顶指针：S.top(指向栈顶元素)
	初始时设置：S.top = -1
	栈顶元素：S.data[S.top]
	栈空：S.top == -1
	栈满：S.top == MaxSize - 1
	栈长：S.top + 1

	进栈操作：栈不满时，栈顶指针先+1，再送值到栈顶元素
	出栈操作：栈非空时，先取栈顶元素值，再将栈顶指针-1
*/

//判空
bool StackEmpty(SqStack S) {
	if (S.top == -1) return true;
	else return false;
}

//要注意的是，需要改动栈本身的时候一定要加&

//入栈
bool Push(SqStack& S, ElemType x) {
	if (S.top == MaxSize - 1) return false;        //栈满

	S.top = S.top + 1;
	S.data[S.top] = x;
	return true;
}


bool Push2(SqStack& S, ElemType x) {
	if (S.top == MaxSize - 1) return false;        //栈满

	S.data[++S.top] = x;
	return true;
}

//出栈
bool Pop(SqStack& S, ElemType& x) {
	if (S.top == -1) return false;                //栈空

	x = S.data[S.top];
	S.top = S.top - 1;
	return true;
}

bool Pop2(SqStack& S, ElemType& x) {
	if (S.top == -1) return false;                //栈空

	x = S.data[S.top--];
	return true;
}

//读取栈顶元素
bool GetTop(SqStack S, ElemType& x) {
	if (S.top == -1) return false;

	x = S.data[S.top];
	return true;
}

//以上所有基本操作时间复杂度为O(1)
//销毁(因为采用的是变量声明的方式分配得内存空间 未使用malloc函数 存储空间的回收由系统自动完成 故只需要完成清空操作即可)
void DestroyStack(SqStack &S) {
	S.top = -1;
}

int main() {
	SqStack S;
	InitStack(S);
	int x;
	bool sign;
	cout << "请连续输入要入栈的值 空格分界 999结束：\n";
	scanf_s("%d", &x);
	while (x != 999) {
		sign = Push(S, x);
		if (sign == false) {//由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生栈上溢，此时应及时向用户报告消息
			cout << "栈最大容量为：" << MaxSize << "，当前栈已满，超出部分未入栈\n";
			break;
		}
		scanf_s("%d", &x);
	}

	int top;
	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop(S, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop2(S, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";
	
	return 0;
}

top指向栈顶元素下一位置:

/*
栈：只允许在一段进行插入或删除操作的线性表
顺序栈：用顺序存储方式实现的栈
*/
#include<cstdio>
#include<iostream>
using namespace std;

#define MaxSize 5                                 //定义顺序栈最大长度
#define ElemType int

typedef struct {
	ElemType data[MaxSize];                        //静态数组存放栈中元素
	int top;                                       //栈顶指针
}SqStack;                                          //顺序栈类型定义   sq:sequence顺序

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

/*
此种设定下：
	栈顶元素的位置：S.top - 1
	初始时设置：S.top = 0
	栈顶元素：S.data[S.top - 1]
	栈空：S.top == 0
	栈满：S.top == MaxSize
	栈长：S.top

	进栈操作：栈不满时，先送值到栈顶元素，栈顶指针再+1
	出栈操作：栈非空时，先将栈顶指针-1，再取栈顶元素值
*/

//判空
bool StackEmpty(SqStack S) {
	if (S.top == 0) return true;
	else return false;
}

//要注意的是，需要改动栈本身的时候一定要加&

//入栈
bool Push(SqStack& S, ElemType x) {
	if (S.top == MaxSize) return false;        //栈满

	S.data[S.top] = x;
	S.top = S.top + 1;
	return true;
}


bool Push2(SqStack& S, ElemType x) {
	if (S.top == MaxSize) return false;        //栈满

	S.data[S.top++] = x;
	return true;
}

//出栈
bool Pop(SqStack& S, ElemType& x) {
	if (S.top == 0) return false;                //栈空

	S.top = S.top - 1;
	x = S.data[S.top];
	return true;
}

bool Pop2(SqStack& S, ElemType& x) {
	if (S.top == 0) return false;                //栈空

	x = S.data[--S.top];
	return true;
}

//读取栈顶元素
bool GetTop(SqStack S, ElemType& x) {
	if (S.top == 0) return false;

	x = S.data[S.top - 1];
	return true;
}

//以上所有基本操作时间复杂度为O(1)
//销毁(因为采用的是变量声明的方式分配得内存空间 未使用malloc函数 存储空间的回收由系统自动完成 故只需要完成清空操作即可)
void DestroyStack(SqStack& S) {
	S.top = 0;
}

int main() {
	SqStack S;
	InitStack(S);
	int x;
	bool sign;
	cout << "请连续输入要入栈的值 空格分界 999结束：\n";
	scanf_s("%d", &x);
	while (x != 999) {
		sign = Push(S, x);
		if (sign == false) {//由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生栈上溢，此时应及时向用户报告消息
			cout << "栈最大容量为：" << MaxSize << "，当前栈已满，超出部分未入栈\n";
			break;
		}
		scanf_s("%d", &x);
	}

	int top;
	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop(S, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop2(S, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	return 0;
}

 共享顺序栈:

/*
栈：只允许在一段进行插入或删除操作的线性表
共享顺序栈：用顺序存储方式实现的栈，且两个栈共享同一个存储空间
*/
#include<cstdio>
#include<iostream>
using namespace std;

#define MaxSize 10                                 //定义顺序栈最大长度
#define ElemType int

typedef struct {
	ElemType data[MaxSize];                        //静态数组存放栈中元素
	int top0;                                      //0号栈栈顶指针
	int top1;                                      //1号栈栈顶指针
}SqStack;                                          //顺序栈类型定义   sq:sequence顺序

//初始化顺序表
void InitStack(SqStack& S) {
	S.top0 = -1;
	S.top1 = MaxSize;
}

/*
此种设定下：
	栈顶指针：S.top0、S.top1  (分别指向各自栈顶元素)
	初始时设置：S.top0 = -1 S.top1 = MaxSize
	栈顶元素：S.data[S.top0]、S.data[S.top1]
	栈空：S.top0 == -1/S.top1 == MaxSize
	栈满：S.top0 + 1 == S.top1

	进栈操作：栈不满时，栈顶指针先+1(对0号栈) -1(对1号栈)，再送值到栈顶元素
	出栈操作：栈非空时，先取栈顶元素值，再将栈顶指针-1(对0号栈)   +1(对1号栈)
*/

//判空
bool StackEmpty(SqStack S,int i) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}

	if (i == 0) {
		if (S.top0 == -1) return true;
		else return false;
	}
	else if (i == 1) {
		if (S.top1 == MaxSize) return true;
		else return false;
	}
}

//要注意的是，需要改动栈本身的时候一定要加&

//入栈
bool Push(SqStack& S,int i, ElemType x) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}
	if (S.top0 + 1 == S.top1) return false;        //栈满
	if (i == 0) {
		S.top0 = S.top0 + 1;
		S.data[S.top0] = x;
		return true;
	}
	else if (i == 1) {
		S.top1 = S.top1 - 1;
		S.data[S.top1] = x;
		return true;
	}
	
}


bool Push2(SqStack& S,int i, ElemType x) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}

	if (S.top0 + 1 == S.top1) return false;        //栈满

	if(i == 0)
		S.data[++S.top0] = x;
	else if (i == 1)
		S.data[--S.top0] = x;
	
	return true;
}

//出栈
bool Pop(SqStack& S,int i, ElemType& x) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}
	if (i == 0) {
		if (S.top0 == -1) return false;                //栈空

		x = S.data[S.top0];
		S.top0 = S.top0 - 1;
		return true;
	}
	else if (i == 1) {
		if (S.top1 == MaxSize) return false;                //栈空

		x = S.data[S.top1];
		S.top1 = S.top1 + 1;
		return true;
	}
}

bool Pop2(SqStack& S,int i, ElemType& x) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}

	if (i == 0) {
		if (S.top0 == -1) return false;                //栈空

		x = S.data[S.top0--];
		return true;
	}
	else if (i == 1) {
		if (S.top1 == MaxSize) return false;                //栈空

		x = S.data[S.top1++];
		return true;
	}
}

//读取栈顶元素
bool GetTop(SqStack S,int i, ElemType& x) {
	if (i != 0 && i != 1) {
		cout << "栈号指定错误 程序退出\n";
		exit(0);
	}

	if (i == 0) {
		if (S.top0 == -1) return false;                //栈空

		x = S.data[S.top0];
		return true;
	}
	else if (i == 1) {
		if (S.top1 == MaxSize) return false;                //栈空

		x = S.data[S.top1];
		return true;
	}
}

//销毁(因为采用的是变量声明的方式分配得内存空间 未使用malloc函数 存储空间的回收由系统自动完成 故只需要完成清空操作即可)
void DestroyStack(SqStack& S) {
	S.top0 = -1;
	S.top1 = MaxSize;
}

int main() {
	SqStack S;
	InitStack(S);
	int x;
	bool sign;
	cout << "请连续输入要入栈0的值 空格分界 999结束：\n";
	scanf_s("%d", &x);
	while (x != 999) {       //实际测试发现，如果此处数值数就已经超过MaxSize break，则后续包含999在内的屏幕数值并未被读取，但会被下面的scanf_s继续读取，其实算个小bug
		sign = Push(S,0, x);
		if (sign == false) {//由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生栈上溢，此时应及时向用户报告消息
			cout << "栈最大容量为：" << MaxSize << "，当前栈已满，超出部分未入栈\n";
			break;
		}
		scanf_s("%d", &x);
	}
	cout << "请连续输入要入栈1的值 空格分界 999结束：\n";
	scanf_s("%d", &x);
	while (x != 999) {
		sign = Push(S, 1, x);
		if (sign == false) {//由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生栈上溢，此时应及时向用户报告消息
			cout << "栈最大容量为：" << MaxSize << "，当前栈已满，超出部分未入栈\n";
			break;
		}
		scanf_s("%d", &x);
	}

	int top;
	cout << "------下面操作栈0------\n";
	sign = GetTop(S,0, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop(S,0, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S,0, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop2(S,0, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S,0, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	cout << "------下面操作栈1------\n";
	
	sign = GetTop(S, 1, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop(S, 1, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, 1, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	sign = Pop2(S, 1, top);
	if (sign == true)
		cout << "出栈元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，出栈失败\n";

	sign = GetTop(S, 1, top);
	if (sign == true)
		cout << "当前栈顶元素为：" << top << "\n";
	else if (sign == false)
		cout << "栈空，读取栈顶元素失败\n";

	return 0;
}

标签：顺序,return,SqStack,ElemType,top,栈顶,C++,数据结构,data
来源： https://blog.csdn.net/Wontoner/article/details/122225042

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有