双栈共享的初始化、入栈、出栈

明里灰

已于 2023-05-09 21:47:09 修改

阅读量1.6k

点赞数 2

CC 4.0 BY-SA版权

分类专栏：总结文章标签：数据结构双栈

于 2023-04-01 15:29:27 首次发布

本文链接：https://blog.csdn.net/m0_73172034/article/details/129895702

总结专栏收录该内容

42 篇文章

订阅专栏

双栈是一种特殊的数据结构，由两个共享同一存储空间的顺序栈组成。它允许元素向中间插入，有效地利用存储空间。文章介绍了双栈的初始化、插入和删除元素（出栈）以及查看栈顶元素的操作，并提供了C语言实现的示例代码。双栈适用于需要多个栈且空间需求动态变化的情况，例如奇偶栈和左右栈，但不适用于栈空间固定且无法扩展的情形。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概念

双栈是指两个顺序栈,是一种特殊的顺序栈。

栈底分别设在数组的头和尾，进栈往中间进就可以了。整个数组存满了才会真的栈满。两栈的大小不是固定不变的，在实际运算过程中，一个栈有可能进栈元素多而体积大些，另一个则可能小些。

优点：

两个栈共用一个栈空间，相互调剂。

缺点：

长度为定值，中途不易扩充。

适用情况：

程序中同时存在几个栈，因为各个栈所需的空间在运行中是动态变化着的。如果给几个栈分配同样大小的空间，可能实际运行时，有的栈膨胀得快，很快就产生了溢出，而其他的栈可能此时还有许多空闲空间，这时就可以用双栈。

常常一个程序中用到多个栈，为了不发生上溢错误，就必须给每个栈配一个足够大的存储空间。但实际中，很难准确地估计，若每个栈都配过大的存储空间，势必造成系统空间紧张；若让多个栈共用一个足够大的连续存储空间，则可利用栈的动态特性使他们的存储空间互补。

双栈包括奇偶栈、左右栈。

其中奇偶栈不能达到很好的互补作用，奇数下标对应一个栈，偶数下标对应一个栈，因为已经确定最大栈的空间了，所以上述的适用情况及优点对于奇偶栈无效。

对于左右栈，它的栈底分别在数组的头和尾，可以直接从中间插入，向中间增长。

双栈的初始化

//双栈的初始化
void InitStack(struct node& S) {
	S.maxt = 100;
	S.bot[0] = 0;
	S.top[0] = S.bot[0];
	S.bot[1] = S.maxt;
	S.top[1] = S.bot[1];
	S.num = (int*)malloc(100 * sizeof(int));
}

插入元素

//插入元素
int PushStack(struct node& S) {
	if (S.top[1] - S.top[0] != 1)
	{
		int x, y;
		printf("输入栈号和插入的元素：");
		scanf("%d%d", &x, &y);
		if (x == 0)
		{
			S.num[S.top[x]++] = y;
			return 1;
		}
		if (x == 1)
		{
			S.num[S.top[x]--] = y;
			return 1;
		}
	}
	return 0;
}

删除元素（出栈）

//删除元素（出栈）
int PopStack(struct node& S) {
	printf("输入要删除栈的栈号：");
	int x, y;
	scanf("%d", &x);
	if (x == 0 && S.top[0] > 0)
	{
		printf("栈号为%d的栈顶元素为%d\n", x,S.num[--S.top[0]]);
		return 1;
	}
	if (x == 1 && S.top[1] < S.maxt)
	{
		printf("栈号为%d的栈顶元素为%d\n", x,S.num[++S.top[1]]);
		return 1;
	}
	return 0;
}

输出栈顶

//输出栈顶
int PrintStack(struct node S) {
	printf("输入要查找栈的栈号：");
	int x;
	scanf("%d", &x);
	if (x == 0)
	{
		int P = S.top[0] - 1;
		if (P > 0)
		{
			printf("%d\n", S.num[P]);
			return 1;
		}
	}
	if (x == 1)
	{
		int P = S.top[1] + 1;
		if (P < S.maxt)
		{
			printf("%d\n", S.num[P]);
			return 1;
		}
	}
	return 0;
}

总代码

#include<stdio.h>
#include<stdlib.h>
struct node {
	int bot[2];
	int top[2];
	int* num;
	int maxt;//最大
};

//双栈的初始化
void InitStack(struct node& S) {
	S.maxt = 100;
	S.bot[0] = 0;
	S.top[0] = S.bot[0];
	S.bot[1] = S.maxt;
	S.top[1] = S.bot[1];
	S.num = (int*)malloc(100 * sizeof(int));
}

//插入元素
int PushStack(struct node& S) {
	if (S.top[1] - S.top[0] != 1)
	{
		int x, y;
		printf("输入栈号和插入的元素：");
		scanf("%d%d", &x, &y);
		if (x == 0)
		{
			S.num[S.top[x]++] = y;
			return 1;
		}
		if (x == 1)
		{
			S.num[S.top[x]--] = y;
			return 1;
		}
	}
	return 0;
}

//删除元素（出栈）
int PopStack(struct node& S) {
	printf("输入要删除栈的栈号：");
	int x, y;
	scanf("%d", &x);
	if (x == 0 && S.top[0] > 0)
	{
		printf("栈号为%d的栈顶元素为%d\n", x,S.num[--S.top[0]]);
		return 1;
	}
	if (x == 1 && S.top[1] < S.maxt)
	{
		printf("栈号为%d的栈顶元素为%d\n", x,S.num[++S.top[1]]);
		return 1;
	}
	return 0;
}

//输出栈顶
int PrintStack(struct node S) {
	printf("输入要查找栈的栈号：");
	int x;
	scanf("%d", &x);
	if (x == 0)
	{
		int P = S.top[0] - 1;
		if (P > 0)
		{
			printf("%d\n", S.num[P]);
			return 1;
		}
	}
	if (x == 1)
	{
		int P = S.top[1] + 1;
		if (P < S.maxt)
		{
			printf("%d\n", S.num[P]);
			return 1;
		}
	}
	return 0;
}
int main()
{
	struct node S;
	InitStack(S);


	//插入元素（入栈）
	if (PushStack(S))
		printf("入栈成功\n");
	else
		printf("入栈失败\n");


	//删除元素（出栈）
	if (PopStack(S))
		printf("出栈成功\n");
	else
		printf("出栈失败\n");


	//输出栈顶
	if (PrintStack(S) == 0)
		printf("查找失败\n");
	return 0;
}