栈ADT+实现

已于 2023-04-04 23:42:50 修改
阅读量671 收藏 4
点赞数
分类专栏： # 数据结构 计算机基础 文章标签： 栈代码实现 顺序存储栈 链式栈
于 2018-12-08 17:47:57 首次发布
本文为博主（@AmosTian）原创文章。1241211485@qq.com
本文链接：https://blog.csdn.net/qq_40479037/article/details/84895114
版权

目录

栈

ADT

代码

 顺序栈

链式栈

栈

仅在队尾进行插入或删除操作的线性表【后进后出的线性表】

栈顶（Top）:线性表表尾

栈底（Base）:线性表表头

ADT

ADT Stack
{
    数据对象：D = {ai|ai∈ElemSet,i = 1,2,...,n, n>= 0}
    数据关系：R1 = {<ai-1,ai>|ai-1,ai∈D,i = 2,...,n}
            约定an端为栈顶，ai端为栈底
    基本操作：
    InitStack(&S);
    操作结果：构造一个空栈
    DestoryStack(&S);
    初始条件:栈S已存在
    操作结果:栈S被销毁
    ClearStack(&S)
    初始条件:栈S已存在
    操作结果:栈S清为空
    StackEmpty(S);
    初始条件:栈S已存在
    操作结果:若栈S为空栈，则返回TRUE,否则返回FALSE
    StackLength(&S)
    初始条件:栈S已存在
    操作结果:返回S元素的个数，即栈的长度
    GetTop(S,&e);
    初始条件:栈S已存在且非空
    操作结果:用e返回栈顶的元素
    Push(&S,e);
    初始条件:栈S已存在
    操作结果:插入元素e为新的栈顶元素
    Pop(&S,&e)
    初始条件:栈S已存在且非空
    操作结果:删除S的栈顶元素，并用e返回其值
    StackTraverse(S,visit());
    初始条件:栈已存在且非空
    操作结果:从栈底到栈顶依次对S的每个数据元素调用函数visit          
}ADT Satck;

代码

 顺序栈

// 顺序栈：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指向栈顶元素在顺序栈中的元素
//数组栈：固定栈的最大元素数量，栈底用索引为0的表示
/*
struct stack
{
char data[100];
int top;
}s;
*/

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

# define STACK_INIT_SIZE 100//存储空间的初始分配
# define STACKINCERMENT 10//存储空间分配增量
# define SElemType int
# define Status int
# define OK 1
# define ERROR 0
# define TRUE 1
# define FALSE 0
# define END 0
# define OVERFLOW -1

typedef struct
{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

//初始化
Status InitStack(SqStack *s)
{
	s->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if (!s)
	{
		printf("内存分配失败!\n");
		exit(OVERFLOW);
	}

	s->top = s->base;
	s->stacksize = STACK_INIT_SIZE;

	return OK;
}

//销毁栈
Status DestoryStack(SqStack *s)
{
	if (!s)
	{
		printf("栈不存在\n");
		return ERROR;
	}

	int len = s->stacksize,i;
	for (i = 0; i < len; ++i)
	{
		free(s->base);
		s->base++;
	}

	s->base = s->top = NULL;
	s->stacksize = 0;
	
	return OK;
}

//判断栈是否为空
Status StackEmpty(SqStack s)
{
	if (!&s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}
	if (s.top == s.base)
		return TRUE;
	else
		return FALSE;
}

//获取栈长度
Status StackLength(SqStack s)
{
	if (!&s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}
	if (StackEmpty(s))
	{
		return 0;
	}

	SElemType *cur = s.base;
	int count = 0;
	while (cur != s.top)
	{
		count++;
		cur++;
	}

	return count;
}

//清空栈
Status ClearStack(SqStack *s)
{
	if (!s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}

	s->top = s->base;

	return OK;
}

//压栈
Status Push(SqStack *s,SElemType e)
{
	//判断栈满
	if (s->top - s->base == s->stacksize)
	{
		s->base = (SElemType *)realloc(s->base, (s->stacksize + STACKINCERMENT) * sizeof(SElemType));
		if (!s)
		{
			printf("内存分配失败!\n");
			exit(OVERFLOW);
		}

		s->top = s->base + s->stacksize;
		s->stacksize += STACKINCERMENT;
	}

	*(s->top) = e;
	s->top++;

	return OK;
}

//出栈
Status Pop(SqStack *s, SElemType *e)
{
	if (StackEmpty(*s))
	{
		printf("空栈\n");
		return ERROR;
	}

	*e = *--s->top;

	return OK;
}

//获取栈顶元素
Status GetTop(SqStack s, SElemType *e)
{
	if (s.top == s.base)
	{
		printf("空栈!\n");
		return ERROR;
	}

	*e = *(s.top - 1);

	return OK;
}

//访问函数
Status visit(SElemType e)
{
	printf("%d ",e);

	return OK;
}

//遍历栈
Status StackTraverse(SqStack s, Status(*visit)(SElemType e))
{
	if (!&s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}

	if (StackEmpty(s))
	{
		printf("栈为空!\n");
		return ERROR;
	}
	SElemType *cur = s.base;

	while (cur != s.top)
	{
		visit(*cur);

		cur++;
	}
	printf("\n");

	return OK;
}

int main()
{
	SqStack stack;
	SElemType data;
	int n,i;

	InitStack(&stack);
	printf("输入压栈次数:\n");
	scanf_s("%d", &n);
	printf("输入栈中数据元素:\n");
	for (i = 1; i <= n; ++i)
	{
		scanf_s("%d", &data);
		Push(&stack, data);
	}
	printf("遍历栈:\n");
	StackTraverse(stack, visit);

	/*
	if (DestoryStack(&stack))
	printf("OK\n");
	printf("弹出栈顶元素为:\n");
	Pop(&stack, &data);
	printf("%d\n",data);
	printf("栈中元素数量为:%d\n", StackLength(stack));
	GetTop(stack, &data);
	printf("栈顶元素是:%d\n",data);
	*/
    return 0;
}

链式栈

// 链式栈.cpp : 定义控制台应用程序的入口点。
//单链表实现栈

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

# define SElemType int
# define Status int
# define OK 1
# define FALSE 0
# define OVERFLOW -1
# define TRUE 1
# define ERROR 0

typedef struct LNode
{
	SElemType data;
	struct LNode *next;
}SNode, *SqStack;

//初始化栈
Status InitStack(SqStack *s)
{
	SNode *head = (SNode *)malloc(1 * sizeof(SNode));
	head->next = NULL;
	if (!head)
	{
		printf("内存分配失败!\n");
		return ERROR;
	}
	*s = head;

	return OK;
}

//清空栈
Status ClearStack(SqStack *s)
{
	SNode *p, *q;

	p = (*s)->next;

	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}

	return OK;
}

//销毁栈
Status DestoryStack(SqStack *s)
{
	if (!(*s))
	{
		printf("栈不存在!\n");
		return ERROR;
	}

	ClearStack(s);

	free(*s);

	return OK;
}

//获取栈中元素数量
Status LengthStack(SqStack s)
{
	int len = 0;

	SNode *target = s->next;

	while (target)
	{
		len++;
		target = target->next;
	}

	return len;
}

//判断空栈
Status EmptyStack(SqStack s)
{
	if (s->next == NULL)
		return TRUE;
	else
		return FALSE;
}

//压栈(头插法)
Status push(SqStack *s, SElemType data)
{
	SNode *node = (SNode *)malloc(1 * sizeof(SNode));

	node->data = data;
	node->next = (*s)->next;
	(*s)->next = node;

	return OK;
}

//弹出栈
Status pop(SqStack *s, SElemType *data)
{
	if (EmptyStack(*s))
	{
		printf("空栈\n");
		return ERROR;
	}

	SNode *p = (SNode *)malloc(1 * sizeof(SNode));

	p = (*s)->next;
	(*s)->next = p->next;
	*data = p->data;
	free(p);

	return OK;
}

//访问函数
Status visit(SElemType e)
{
	printf("%d ",e);

	return OK;
}

//遍历栈
Status TraverseStack(SqStack s,Status (*visit)(SElemType e))
{
	if (!s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}

	if (EmptyStack(s))
	{
		printf("空栈!\n");
		return ERROR;
	}

	SNode *target = s->next;
	for (; target; target = target->next)
	{
		visit(target->data);
	}

	return OK;
}

//返回栈顶元素
Status GetTop(SqStack s,SElemType *e)
{
	if (!s)
	{
		printf("栈不存在!\n");
		return ERROR;
	}

	if (EmptyStack(s))
	{
		printf("空栈\n");
		return ERROR;
	}

	*e = s->next->data;

	return OK;
}

int main()
{
	SqStack stack;
	int n;
	SElemType data;

	InitStack(&stack);

	printf("输入栈的元素个数:");
	scanf_s("%d", &n);
	while (n--)
	{
		scanf_s("%d",&data);
		push(&stack, data);
	}
	
	printf("遍历栈\n");
	TraverseStack(stack, visit);

	DestoryStack(&stack);

	/*
	pop(&stack, &data);
	printf("删除的元素是:%d\n",data);
	printf("遍历栈\n");
	TraverseStack(stack, visit);
	GetTop(stack, &data);
	printf("栈顶元素为:%d\n",data);
	//printf("栈元素个数为:%d\n",LengthStack(stack));
	*/

    return 0;
}

AmosTian
关注
专栏目录
抽象数据类型——栈ADT(二）
little_nine的博客
08-09 398
(一）栈的定义 栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶。 对栈的基本操作有Push（进栈）和Pop（出栈），前者相当于插入，后者则是删除最后插入的元素。最后插入的元素可以通过使用Top例程在执行Pop之前进行考查。 栈的一般模型是，存在某个元素位于栈顶，而该元素是唯一可见的元素。 （二）栈的实现 1.栈的链表实现 在编写例程之前，我们先给出定义...
栈 ADT（链表实现）
SGHY_hus的博客
01-24 354
栈模型     栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈的顶部（Top）。栈又叫做 LIFO (后进先出)表。 栈的实现     由于栈是一个表，阴恻任何实现表的方法都可以实现栈。     在这里我们使用链表方法。 栈链表实现的类型声明： #ifndef _Stack_h struct Node; typedef struct Node *PtrToNode;
8、顺序栈ADT模板简单应用算法设计：迷宫问题
windyuan~
03-17 826
问题描述 : 目的：使用C++模板设计顺序栈的抽象数据类型（ADT）。并在此基础上，使用顺序栈ADT的基本操作，设计并实现简单应用的算法设计。 内容：（1）请参照顺序表的ADT模板，设计顺序栈的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的顺序表ADT原型文件，自行设计顺序栈的ADT。） （2）ADT的简单应用：使用该ADT设计并实现若干应用顺序栈的算法设计。 ..
《数据结构与算法分析》学习笔记（四）——栈ADT
weixin_33704234的博客
01-08 222
一、栈ADT是what？ 1、定义         栈，是限制插入和删除都只能在一个位置上进行的表。 2、图示                                         3、栈的基本功能 （1）是否为空 （2）进栈 （3）出栈 （4）清空 （5）取栈顶 二、栈的链表实现   #ifndef Exercise_Stack_h #define Ex...
栈ADT
detscaozv622278146的博客
05-23 110
栈是限制插入和删除都只能从一个位置上操作的表，该位置是表的末端，表的末端一般叫做栈顶，对栈的基本操作有push（进栈） 插入 和 pop（出栈）删除，前者相当于在表最后的位置上插入元素，后者相当于删除最后进入栈的元素，俗称也叫先进后出表，后进先出表，我们对栈的基本操作也就是 push和pop，一般栈的模型就是存在某个元素位于栈的顶部，并且该元素是唯一可见的元素， 由于栈是一个表，所以任...
ADT的栈的实现
站在人文与技术的交汇点
01-10 2309
ADT，称为抽象数据类型。所谓抽象数据类型，即定义一种数据形式，并封装该数据的操作方法。 参考链接： http://blog.csdn.net/qscool1987/article/details/7179791， 这里我们在C++中实现一种“栈”的抽象数据类型。首先介绍一下栈：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相
C_栈和队列(ADT)-栈的表示和实现
Cynical丶Gary_博客
07-16 794
基本操作的实现：栈的构造，判空，插入，删除，清空，销毁，打印 栈的定义： typedef struct{ ElemType *base; //栈底指针 ElemType *top; //栈顶指针 int stacksize; }SqStack; 栈的基本操作: /*操作构造一个空栈S。*/ InitStack(&S); /*初始条件：栈S已存在。*/ /*操作
顺序栈ADT数据结构代码
12-02
1. **顺序栈ADT定义** 顺序栈是一种具有栈的基本操作的数据结构，包括： - `InitStack()`: 初始化栈。 - `DestroyStack()`: 销毁栈。 - `ClearStack()`: 清空栈。 - `StackEmpty()`: 判断栈是否为空。 - `...
哈尔滨工业大学软件设计I 常用数据结构ADTc++实现 (使用模板类)保证原创
01-31
《哈工大软件设计I：常用数据结构ADT的C++实现（模板类）》 在计算机科学领域，数据结构是研究数据存储和组织方式的关键部分。它涉及到如何有效地存储和检索数据，对于提高程序效率至关重要。哈尔滨工业大学的软件...
数据结构：栈ADT的实现
Viadimir的博客
04-18 1530
栈是一种特殊的线性表，是一种线性数据结构，其特殊性是表现在操作定义上：插入和删除操作只能在两端进行（不允许在线性表的中间插入和删除）。 栈（Stack）： 数据结构————线性关系 操作————一端固定，只允许一端插入删除 特性————“先进的先出，后进的后出” 栈有两种存储方式，一种是顺序存储（顺序栈），另一种是链式存储（链式栈）。 这里我以链式栈为例子给大家讲解栈ADT的定义。...
数据结构与算法分析c语言描述（Mark Allen）--栈ADT链表实现
OCEANtroye的博客
10-20 785
栈ADT链表实现 使用链表存储 操作集合 入栈push 出栈pop 清空 初始化 返回栈顶元素 打印整个栈 #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;time.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #ifndef _Stack_H struct Node; typedef int Element
栈ADT实现
Bean_Cao的博客
08-16 477
栈的定义： 　　栈是限制插入和删除只能在一个位置上的进行的线性表，该位置是线性表的末端，称为栈顶（Top）。栈的基本操作有Push（进栈），Pop（出栈），Top（查看栈顶元素）。 栈又被称为先进后出（FILO）表。 栈的实现： 由于栈是一种线性表，因此任何实现表的方法都可以实现栈； 栈的链表实现： 栈的数组实现： 栈的应用：
数据结构-->栈的顺序实现 ADT
Warren's Blog
07-09 637
typedef int SElemType; typedef struct LNode { SElemType *base;//栈底地址 SElemType *top;//栈顶地址 int stacksize; //可用的最大容量 }SqStack;bool InitStack(SqStack &S) { S.base = new SElemType[MAXSIZE]
数据结构与算法 -- 栈 ADT
不积跬步，无以至千里
02-14 7926
这两天翻了下数据结构与算法分析和严蔚敏的数据结构这两本书，受益很多。不过大多的示例不够完整，需要自己动手编写程序。又看了遍培训时的笔记，虽然很糙但是精华的部分还是可以借鉴的。还有看到了不错的博文，参看：数据结构与算法分析 学习笔记 对于数据结构与算法，尽量做到多方面的参考。多的不说了，下面就开始总结！！ 一、首先讲一些基本的概念 1、数据结构的基本概念： 在计算机学科中数据结构表示数据在
栈的简单介绍以及栈结构的ADT【数据结构】
qq_46474413的博客
05-28 370
几种基本的栈结构操作
C语言实现顺序栈与ADT描述
在C语言中，顺序栈通常通过数组实现，其数据结构定义如下： ```c #define MAXSIZE 1024 typedef struct { ElemType data[MAXSIZE]; // 顺序栈的核心部分，用于存储数据元素，最大容量为MAXSIZE int top; // 栈顶...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AmosTian

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值