数据结构(C语言)顺序栈

已于 2023-10-21 17:54:00 修改
阅读量67 收藏
点赞数
文章标签： 数据结构
于 2023-10-21 17:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HandsomeYongYong/article/details/133963431
版权

顺序栈的定义

        顺序栈是栈的顺序实现，栈是一种线性数据结构，采用地址连续的存储空间，遵循先进后出（FILO，First-In-Last-Out）的原则。即最后进入栈的元素将首先被弹出，类似于堆叠物品的过程。

顺序栈的特点

  1. 遵循后进先出（FILO）原则。
  2. 利用栈顶指针标识栈顶元素。
  3. 初始化为空栈，随着元素入栈和出栈，栈的大小动态变化。
  4. 常用于需要维护后进先出顺序的问题，如函数调用栈、表达式求值等。

顺序栈的运算

  1. 初始化栈：创建一个空栈。

  2. 入栈：将元素放入栈顶。

  3. 出栈：从栈顶取出元素。

  4. 获取栈顶元素：查看栈顶元素但不移除。

  5. 判空：检查栈是否为空。

  6. 获取栈大小：获取栈中元素的个数。

  7. 清空栈：移除栈中所有元素，使栈为空。

  8. 销毁栈：释放栈的内存。

顺序栈的实现 

定义顺序栈

typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;

初始化

/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}

入栈

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}

出栈

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}

获取栈顶元素

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}

判断栈是否为空 

/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}

判断栈是否已满 

/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}

 销毁栈

/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

 运行结果截图

顺序栈的应用 

十进制转换为二进制

/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
}

后缀表达式计算

/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			printf("%c\n",exp[i]);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
 
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

 

 完整Demo

main.c

#include <stdio.h>
#include "seqstack.c"
#include "welcome.h"
 
 
int main(int argc, char* argv[])
{
	SeqStack S;
	DataType x;
	int maxsize;
	char yn;
	int i,m,n,cmd,d;
;
	for(i=0;i<strlen(welcome);i++)
	{
		printf("%c",welcome[i]);
		for(m=0;m<1000;m++)
			for(n=0;n<1000;n++)
			{
				;
			}
	}
	
		printf("---------顺序栈演示程序-----------\n");
	do
	{
		printf(" 1. 初始化\n");
		printf(" 2. 入栈\n");
		printf(" 3. 出栈\n");
		printf(" 4. 查找栈顶元素\n");
		printf(" 5. 判断栈为是否空\n");
		printf(" 6. 判断栈为是否满\n"); 
		printf(" 7. 销毁栈\n"); 
		printf(" 8. 栈的应用\n");
		printf(" 9. 帮助\n");
		printf("请选择（0~9,0退出)：");
		scanf("%d", &cmd);
		switch(cmd)
		{
		case 1:
			printf("请输入栈的最大存储空间(MaxSize)：");
			scanf("%d", &maxsize);
			if(!init(&S, maxsize))
			{
				printf("栈已初始化！\n");
			}
			break;
		case 2:
			printf("请输入入栈元素：x=");
			scanf("%d", &x);
			if(!push(&S, x))
			{
				printf("元素【%d】已入栈！\n", x);
 
			}
			break;
		case 3:
			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
			fflush(stdin);
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}
 
			break;
		case 4:
			if(!get_top(&S,&x)){
				printf("查找到栈顶元素[%d]\n",x); 
			}
			break; 
		case 5:
			if(empty(&S)){
				printf("栈为空！\n"); 
			}else{
				printf("栈内存在元素\n"); 
			}
			break;
		case 6:
			if(full(&S)){
				printf("栈满！\n"); 
			}else{
				printf("栈未满\n"); 
			}
			break;
		case 7:
			destroy(&S);
			printf("栈已销毁\n"); 	
			break;
		case 8:
			do
			{
				printf("----------8.栈的应用------------\n");
				printf(" 1. 十进制转换为二进制\n");
				printf(" 2. 后缀表达式计算\n");			
				printf(" 0. 返回\n");
				printf("请选择：");
				scanf("%d", &cmd);
 
				if(cmd == 1)
				{
					printf("请输入一个十进制数：");
					scanf("%d", &d);
					printf("二进制为：");
					d_to_b(d);
					printf("\n");
				}
 
				if(cmd == 2)
				{
					expression();
				}
			}while(cmd!=0);
			cmd = -1;
			break;
		case 9:
			printf(" 本程序为栈的演示程序，由陈勇豪设计开发，程序完成了栈的基本功能！\n");		
		default:
			printf("输入选项不存在\n"); 		
		}
 
	}while(cmd!=0);
 
	return 0;
}
/*十进制转换为二进制*/
int d_to_b(int d)
{
	SeqStack S;
	int b;
 
	/*初始化栈*/
	init(&S,32);
 
	/*d不为0，余数进栈*/
	while(d)
	{
		push(&S, d % 2);
		d /= 2;
	}
	
	/*依次出栈*/
	while(!empty(&S))
	{
		pop(&S,&b);
		printf("%d", b);
	}
 
	/*销毁栈*/
	destroy(&S);
}
 
 
/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int x;
 
	char exp[20]; /*后缀表达式*/
 
	init(&S, 10);
 
	printf("请输入一个后缀表达式(eg. 56+):");
	scanf("%s", exp);
	for(i=0;i<strlen(exp);i++)
	{
		switch(exp[i])
		{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			/*入栈*/
			push(&S, exp[i]-48);
			printf("%c\n",exp[i]);
			break;
		case '+':
			/*出2个*/
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 + op2;
			push(&S, x);
			break;
 
		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			push(&S, x);
			break;
		case '-':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2- op1;
			push(&S, x);
			break;
		case '/':
			pop(&S, &op1);
			pop(&S, &op2);
			x =  op2/op1;
			push(&S, x);
			break;	
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

seqstack.c

#include "seqstack.h"
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
	/*申请内存空间*/
	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
 
	if(!S->data)
	{
		printf("内存申请错误，初始化失败！[10001]\n");
		return 10001;
	}
	S->maxsize = MaxSize;
	S->top = -1;
	return 0;
}
 
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
	/*是否满？*/
	if(full(S))
	{
		printf("栈已满！10002\n");
		return 10002;
	}
 
	S->top++;			/*移动指针*/
	S->data[S->top] = x;/*放入数据*/
	return 0; /*OK*/
}
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
	S->top--;				/*移动栈顶指针*/	
 
	return 0;
}
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
	/*是否空？*/
	if(empty(S))
	{
		printf("栈为空！10003\n");
		return 10003;
	}
 
	*x = S->data[S->top];	/*栈顶元素赋值给x*/
 
	return 0;
}
 
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
	return (S->top == -1)?1:0;
}
 
/* 6. 栈满？*/
int full(SeqStack *S)
{
	return (S->top == S->maxsize - 1)?1:0;
}
 
 
/* 7. 销毁*/
int destroy(SeqStack *S)
{
	free(S->data);
	return 0;
}

seqstack.h

typedef int DataType;
 
 
typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;
 
 
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);
 
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);
 
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);
 
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);
 
/* 5. 栈为空？*/
int empty(SeqStack *S);
 
/* 6. 栈满？*/
int full(SeqStack *S);
 
/* 7. 销毁*/
int destroy(SeqStack *S);

welcome.h

char welcome[] = "\n\
                               \n\                      
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIII    IIIIIIIIIII     IIIIIII\n\                              
                                  IIIIIII     IIIIIIIIII   IIIIIII\n\                              
                                  IIIIIIIII     IIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIII       IIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIII        IIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIII         IIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIII         IIIIII\n\                              
                                  IIIII    IIIIIIIIIII        IIII\n\                              
                                  IIIII     IIIIIIIIIII      IIIII\n\                              
                                  IIIII      IIIIIIIIIII    IIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\                              
                                  IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n\n\n\                                                                                                               
      IIIIIIIII.           .IIIIIIIII.       IIIIIIIIIIIII          I            .IIIIIII.\n\      
      III      III        III       III      I.   III   .I         III          III    III\n\      
      III       III      III         III          III             II II               III\n\       
      III        III     III          II          III            II  III             III\n\        
      III        III     III          II          III           II    III           III\n\         
      III       III       III        II           III          II      III         III\n\          
      III      II          IIII     II            III          IIIIIIIIIII        III    .I\n\     
      IIIIIIIIII             IIIIIII              III          II       II       IIIIIIIIII\n\n";

小结 

        顺序栈是一种利用顺序存储结构实现的栈，遵循后进先出（FILO）原则。这种数据结构非常简单而高效，适用于多种应用场景。它的关键操作包括入栈、出栈、查看栈顶元素、判空、获取栈大小、清空栈和销毁栈。顺序栈操作高效，但容量通常有限，需注意动态扩展。它在括号匹配、表达式求值、历史记录、算法等方面有广泛应用。

参考文献：《数据结构（C语言版）》李刚、刘万辉主编，高等教育出版社。OpenAI

那一日的约定
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
顺序栈ADT数据结构代码
12-02
总结，顺序栈是一种重要的数据结构，它在C语言中通过结构体和数组实现。`SqStack.c`和`SqStack.h`文件定义了顺序栈的操作，`main.c`提供了测试代码，而`RandomElementFactory.c/h`文件则可能提供了辅助的随机元素...
C语言数据结构之栈简单操作
01-01
C语言数据结构之栈简单操作 实验： 编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能： （1）初始化顺序栈 （2）插入元素 （3）删除栈顶元素 （4）取栈顶元素 （5）遍历顺序栈 ...
C语言栈顺序结构实现代码
09-04
在C语言中，栈是一种非常基础且重要的数据结构，它遵循“后进先出”（LIFO）的原则。本文将详细介绍如何使用C语言实现一个自动扩容的顺序结构栈，即ArrStack实例，该实例适用于GCC编译环境。 首先，我们需要定义栈...
数据结构 严蔚敏 C语言版 顺序栈
01-16
这里我们将深入探讨严蔚敏教授的C语言版数据结构教程中的顺序栈。 顺序栈是指在内存中连续分配空间的栈实现方式，它的优点在于存储效率高，操作简单。栈的主要操作有压栈（push）和弹栈（pop），以及查看栈顶元素...
C语言通过使用数据结构来实现双向顺序栈
12-27
双向顺序栈（Double-ended sequential stack）是一种栈数据结构，它允许在两个方向上进行入栈和出栈操作。与常规栈不同，双向顺序栈具有两个栈顶位置，一个在栈的一端，称为"头栈顶"（head），另一个在栈的另一端，...
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 659
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
算法复杂度＜数据结构 C版＞
hukang的博客
07-13 1744
简单来说算法复杂度是用来衡量一个算法的优劣的，一个程序在运行时，对运行时间和运行空间有要求，即时间复杂度和空间复杂度。
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 492
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构第35节 性能优化 算法的选择
最新发布
hummhumm的专栏
07-18 410
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1855
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 227
1%29%5D。
【数据结构】二叉树-1
m0_46676283的博客
07-15 870
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
【数据结构】线性结构——数组、链表、栈和队列
Filotimo_的博客
07-15 1202
线性结构是指数据元素之间存在一对一的关系，包括数组、链表、栈和队列等。这里介绍了这四种数据结构的优缺点和适用场景。
5Python的Pandas：数据结构
XiaoCai
07-13 653
Pandas是基于强大的NumPy库开发的，它继承了NumPy中的一些数据结构，也继承了NumPy的高效计算特性。
【数据结构】手写快速排序
qq_59143106的博客
07-14 308
什么是快速排序？首先确立pivot，比如下图位于末尾然后i遍历3到6在3的时候，j指向i前面一位如果3
【Java--数据结构】栈的应用
2301_80898480的博客
07-14 756
如有错误，欢迎指出~
【C语言】全面解析冒泡排序
Easonmax的博客
07-15 927
冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复遍历待排序的序列，依次比较相邻元素并交换它们的位置，使较大的元素逐渐“冒泡”到序列的末端。冒泡排序的核心思想是通过不断的比较和交换，将未排序的元素逐步移到正确的位置。
数据结构小测试：排序算法
m0_63432840的博客
07-14 597
冒泡排序：将相邻元素之间的比较和交换，使得每一轮比较后，最大的元素能够到达数组的末尾。重复这个过程，直到整个数组有序。选择排序：在每一轮中，找到数组中最小的元素，并将其与当前轮的第一个元素交换位置。重复这一操作，使得每一轮过后，都有一个元素被放到了正确的位置上。插入排序：将数组分为已排序部分和未排序部分，每次从未排序部分取出一个元素，插入到已排序部分的正确位置上。希尔排序：首先确定一个间隔序列，按此间隔将数组元素分组并进行插入排序。随后逐渐缩小间隔并重复排序过程，直到间隔为1。
数据结构第29节 后缀树和后缀数组
hummhumm的专栏
07-15 509
后缀树和后缀数组都是用于高效处理字符串搜索问题的数据结构，它们特别适合于解决涉及字符串模式匹配、重复子串查找等问题。下面我将结合Java代码解释这两种数据结构的基本概念以及如何构建它们。
数据结构c语言-顺序栈
10-05
在C语言中，顺序栈的存储结构可以使用一个一维数组来存放栈中的元素，同时使用一个指示器top来指示栈顶的位置。在进行进栈和出栈操作时，需要更新top的值，使其指向栈顶元素。 下面是一种常见的顺序栈的定义和基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值