第三章-栈（一）

最新推荐文章于 2022-05-24 17:11:03 发布
最新推荐文章于 2022-05-24 17:11:03 发布
阅读量256 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40191710/article/details/79069851
版权
栈

------------------------------------------------------------------------------------------------

1、定义 ：         限定只能在表的一端进行插入和删除运算的线性表（只能在栈顶操作）表尾端。
2、逻辑结构：   与线性表相同，仍为一对一关系
3、存储结构：   只能在栈顶运算，且访问结点时依照后进先出（LIFO）或先进后出（FILO）的原则
4、运算规则：  只能在栈顶运算
5、实现方法：  关键是编写入栈和出栈函数，具体实现依顺序栈或链栈的不同而不同
                        基本操作有入栈、出栈、读栈顶元素值、建栈、或判断栈满、栈空等。


6、栈的物理结构
                     

注意：在每次入栈的时候， top 指针会在存储的位置的上一个位置：



7、栈的抽象数据类型定义：
     ADT{
               数据对象：D={ ai | ai 属于 ElemSet,i=1,2 ,.... , n,   n>=0 }
               数据关系：R1={ < ai-1 , ai > | ai-1 , ai 属于 D , i=2, ... , n}
                             约定 an 端为栈顶， a1 端为栈底。
               基本操作：
                        InitStack(&S)
                           操作结果：构造一个空栈S。

                        DestroyStack(&S)
                           初始条件：栈S已存在。
                           操作结果：栈S被销毁。

                        ClaerStack(&S)
                           初始条件：栈S已存在。
                           操作结果：将栈S清空为空栈

                        StackEmpty(&S)
                           初始条件：栈S已存在。
                           操作结果：若栈为空栈，则返回TRUE，否则FLASE。

                        StackLength(&S)
                           初始条件：栈S已存在。
                           操作结果：返回S的元素个数，即栈的长度

                        GetTop(S，&e)
                           初始条件：栈S已存在且非为空。
                           操作结果：用e返回S的栈顶元素

                        Push(&S，e)
                           初始条件：栈S已存在。
                           操作结果：插入元素 e 为新的栈顶元素

                        Pop(&S)
                           初始条件：栈S已存在且非为空。
                           操作结果：删除S的栈顶元素，并用e返回其值

                        StackTraverse( S， visit() )
                           初始条件：栈S已存在且非为空。
                           操作结果：从栈底到栈顶依次对S的每个元素调用 Visit（） 。一旦Visit（）失败，则操作失                                                  败。

     }ADT Stack


8、栈的条件：
             栈不存在的条件 ： base =NULL；
             栈为空的条件：      base=top；
              栈满的条件：        top- base=stacksize；
             
                          

9、栈的实现：（和线性表类似，栈也有两种存储方式）
     顺序栈的操作系统：
完整代码：

注：需要以  .cpp 为后缀名 


//头文件
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

//宏定义
#define STACK_INIT_SIZE 100     //存储空间初始分配量
#define STACKINCREMENT 10         //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int SElemType;
typedef int Status;

//栈的顺序结构体
typedef struct{
	SElemType *base;              //在栈构造之前和销毁之后，base 的值为NULL;
	SElemType *top;               //栈顶指针
	int stacksize;                //当前已分配的存储空间，以元素为单位
}SqStack;

//------------基本操作的函数原型说明--------------
//Status InitStack(SqStack &S);      //构造一个空栈S

//Status DestroyStack(SqStack &S);   //销毁栈S，S不再存在

//Status ClearStack(SqStack &s);     //把栈S置位空

//Status StackEmpty(SqStack S);    //若栈S为空栈，则返回TRUE，否则返回FALSE

//int StackLength(SqStack S);      //返回S的元素个数，即栈的长度

//Status GetTop(SqStack S,SElemType &e);     //若栈不为空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR

//Status Push(SqStack &S,SElemType e);        //插入元素e为新的栈顶元素

//Status Pop(SqStack &S,SElemType &e);        //若栈不为空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR

//Status StackTraverse(SqStack S,Status (*visit) () );      
        //从栈底到栈顶依次对栈中每个元素调用函数 visit() , 一旦 visit() 失败，则操作失败

//1.构建栈
Status InitStack(SqStack &S){
	//构造一个空栈S
	S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(! S.base) exit(OVERFLOW);  //存储分配失败
	S.top=S.base;    //当栈为空时，栈底等于栈顶
	S.stacksize=STACK_INIT_SIZE;    //栈可存储的个数
	return OK;
}

//2.销毁栈
Status DestroyStack(SqStack &S){
	S.top=NULL;
	S.stacksize=0;
	free(S.base);
	return OK;
}

//3.清空栈
Status ClearStack(SqStack &S){
	S.top=S.base;   //栈顶和栈底指向同一个位置，即为空
	return OK;
}

//4.判断栈是否为空
Status StackEmpty( SqStack S)
{
	if(S.top==S.base)
		return ERROR;
	else
		return TRUE;
}

//5.求栈的长度
Status StackLength(SqStack S)
{
	int n;
	if(S.top==S.base)
		return FALSE;
	else{
		n=S.top-S.base;
		return n;
	}
}

//6.求栈顶元素
Status GetTop(SqStack S,SElemType &e)
{
	if(S.top==S.base)
		return FALSE;
	else
		return ( e=*(S.top-1) );
}

//7.栈顶插入元素
Status Push(SqStack &S,SElemType &e)
{       //插入元素 e 为新的栈顶元素
	if(S.top-S.base >= STACK_INIT_SIZE)  //栈满的时候就需要追加存储空间
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));	
		if(!S.base)  exit(OVERFLOW);    //存储空间分配失败

		S.top=S.base+S.stacksize;   //栈底的位置可能改变，需要重新定位栈顶元素
		//S.top 还是之前的那个没有存储的位置   

		S.stacksize = S.stacksize+STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return OK;
}


//8.栈顶出栈元素
Status Pop(SqStack &S,SElemType &e){
	//若栈不为空，则删除 S 的栈顶元素，用 e 返回其值，并返回 OK ，否则返回ERROR
	if(S.top == S.base)  return ERROR;
	e=*(--S.top);     //可以不加括号，但需要记住的是，需要让 top 指针减 1 ，再取出元素
	return OK;
}

//9.遍历栈 
Status StackTraverse(SqStack S){
	if(S.base==NULL)  return ERROR;
	if(S.top==S.base){
		printf("栈为空，没有元素-------！");
		return FALSE;
	}
	SElemType *p=S.top;   //先找出 top 的地址
	while(p > S.base)
	{
		p--;
		printf("%d\n",*p);
	}
	return OK;
}
/*
Status StackTraverse(SqStack S,Status (*visit) () )
{
	whlie(S.top != S.base)
		visit(--S.top); //先把指针减 1 ，再输出其元素 
}
*/

//主函数
void main(){
	SqStack S;
	int whilenum=1;
	int stack_length;
	int word;
	char anykey;
	int IS_Result;
	do{
			printf("------------------------------Use Stack----------------------------\n");
        	printf("1.Buliding an empty Stack. \n");
        	printf("2.Destruction of the Stack. \n");
    		printf("3.Clear the Stack. \n");
    		printf("4.Determines whether the Stack is empty. \n");
    		printf("5.Caculate the Stack length.  \n");
    		printf("6.Obtain the top element Stack. \n");
    		printf("7.Insert elements into the top of the Stack. \n");
    		printf("8.The output Stack top element. \n");
    		printf("9.Ergodic output stack. \n");
    		printf("10.The end of the Stack. \n");
    		printf("11.\n");
    		printf("12.\n");
    		printf("13.\n");
			printf("--------------------------------------------------------------------\n");

		whilenum=1;
		int choice;
		printf("Please enter your choice.\n");
		scanf("%d",&choice);

		switch(choice){
			//初始化栈
		case 1:
			printf("Buliding an empty Stack.\n");
        	IS_Result=InitStack(S);
        	if(IS_Result=1)
     	    	printf("Construct an empty Stack.\n");
        	else
	        	printf("Rrror\n");
        	printf("\n\n");
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//销毁栈
		case 2:
			printf("Destruction of the Stack.\n");
			if(DestroyStack(S)==1)
				printf("Destruction of the Stack succeed. \n");
			else
				printf("Destruction of the Stack succeed error. \n");
			printf("anykey to continue!");
			break;

			//清空栈
		case 3:
			printf("Clear the Stack.\n");
			if(ClearStack(S)==1)
				printf("Clear the Stack succeed.\n");
			else
				printf("Clear the Stack error.\n");
			printf("anykey to continue!");
			break;

			//判断栈是否为空
		case 4:
			printf("The Stack is empty?  \n");
			if( StackEmpty(S) == 1)
				printf("NO!\n");
			else
				printf("YES!\n");
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//Calculate the stack length.
		case 5:
			printf("Calculate the stack length,the length of Atack is:");
			stack_length=StackLength(S);
			printf("%d",stack_length);
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//获得栈顶元素
		case 6:
			printf("Get the top element of the stack.\n");
			GetTop(S,word);
			printf("the word is : %d",word);
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//入栈
		case 7:
			printf("Please enter the char you want to enter.");
			scanf("%d",&word);
			Push(S,word);
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//出栈
		case 8:
			printf("The output Stack top element.\n");
			Pop(S,word);
			printf("the word is : %d",word);
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//遍历栈
		case 9:
			printf("Traverse the Stack:");
			StackTraverse(S); 
			printf("anykey to continue!");
			scanf("%c",&anykey);
			scanf("%c",&anykey);
			break;

			//结束
		case 10:
			printf("Succeding end. \n");
			whilenum=0;
			break;
		}

		system("cls");
	}while(whilenum);
}





                                                                                     如有错误，敬请指出！
       
























             
             
             
qq_40191710
关注
专栏目录
数据结构学习（3.栈与队列）
cyw887733的博客
03-12 1110
数据结构学习笔记（3.栈与队列）顺序栈，链栈，顺序循环队列，链队列
数据结构——栈知识总结
qq_43215434的博客
11-10 830
一、栈 1、栈的逻辑结构 栈：限定仅在表尾进行插入和删除操作的线性表。 空栈：不含任何数据元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的操作特性：后进先出。 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStack 前置条件：栈不存在 ...
第3章 栈和队列
summertime_sadness的博客
01-15 298
3.1 栈的定义及抽象数据类型 栈（stack）是一种特殊的线性表，这种表只能在固定的一端进行插入与删除运算。通常称固定插入、删除的一端为栈顶（top），而另一端称为栈底（bottom）。位于栈顶和栈底的元素分别称为顶元和底元。当表中没有元素时，称为空栈。为了与一般的线性表相区别，通常将栈的插入操作称为入栈，将删除操作称为出栈。 线性表S=（a,b,c,d,e） 将S中的元素按照a、b、c、...
栈的基本操作（C语言）
absorb2601078490的博客
05-24 8628
本文只有代码，介绍了有关栈的基本操作。 已经过调试没有很大问题。 如有错误，还请批评指正。
顺序栈的初始化，进栈、出栈、求长、判空、访顶、遍历、清空、销毁
刘明的博客
06-04 1万+
顺序栈即栈的顺序存储结构，它利用一组地址连续的存储单元存放自栈底到栈顶的元素，是一种后进先出(last in first out,LIFO)的线性表。      判断栈不存在的条件为：S.base=NULL;      空栈：S.base=S.top;       满栈：S.top-S.base=S.stacksize;  #include "stdafx.h" #include
数据结构作业：第三章-栈和队列题目.docx
12-17
数据结构作业：第三章-栈和队列题目 本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 ...
数据结构作业：第三章-栈和队列作业答案.docx
12-14
本资源摘要信息是关于数据结构第三章栈和队列的作业答案，涵盖了栈和队列的基本概念、操作原则、特点及应用场景。下面是对该资源的详细解读： 1. 栈的操作原则 栈是一种 Last-In-First-Out（后进先出）的数据结构...
《数据结构》习题汇编03-第三章-栈与队列-试题.pdf
10-31
第三章栈和队列习题汇编主要涵盖了栈和队列的基本概念、实现方式、操作特点等知识点。下面对每个知识点进行详细的解释： 1. 栈的插入和删除操作在栈顶进行。栈的这种特点是为了实现后进先出的原则，即最后插入的...
第3章-栈和队列1
08-03
**栈**是一种遵循“后进先出”（LIFO，Last In First Out）原则的数据结构。在栈中，最近添加的元素（称为栈顶元素）将是最先被移除的。栈的操作主要包括**进栈（Push）**，即将元素添加到栈顶，和**出栈（Pop）**，...
《数据结构》第三章-栈与队列 思维导图
最新发布
01-11
栈及栈的特性、队列及队列的特性、循环队列、链队列、共享栈等
C语言实现数据结构——栈（Stack）
weixin_51408717的博客
10-14 1万+
C语言数据结构之堆栈（Stack）栈的定义及原理概述图解优缺点栈的主要操作实现代码1. Status.h文件代码2. SqStack.h文件代码3. SqStack.c函数实现文件代码4. SqStack_main功能测试主函数代码 栈的定义及原理 概述 栈是一个先进后出的数据结构，类似于一个弹匣，栈中的数据就相当于弹匣中的子弹 在栈中进行操作的时候 只预留了一个端口进行数据的存取操作，即无论是向数据结构中添加新的数据还是将其中的已有数据删除，只能从栈的一段进行操作 图解 数据入栈示意图 先将数据压
3.1.2顺序栈(存储结构由c3-1.h定义)的基本操作
SJMP
11-06 1008
/* bo3-1.c 顺序栈(存储结构由c3-1.h定义)的基本操作(9个) */  void InitStack(SqStack *S)  { /* 构造一个空栈S */    (*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));    if(!(*S).base)      exit(OVERFLOW);
栈的基本操作【严蔚敏】
MooMLu的博客
04-22 937
typedef struct SqStack { SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */ SElemType *top; /* 栈顶指针 */ int stacksize; /* 当前已分配的存储空间，以元素为单位 */ }SqStack; /* 顺序栈 */ Status InitStack(SqStack *
数据结构（栈 建立一个栈，入栈再出栈）
热门推荐
GinSmile的博客
03-20 2万+
建立一个栈，入栈再出栈。 #include #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OVERFLOW -2 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 using namespace std; typedef int SElemTyp
* & 的问题 （待整理）
weixin_30545285的博客
04-22 669
资料：http://tieba.baidu.com/f?kz=1053435983 void InitStack( SqStack *&S) 浏览次数：3426次悬赏分：5|解决时间：2006-8-12 00:19|提问者：dangdangxww 为什么这个S形参前面用了* 和&呢？是怎么个用法，含义如何呀？ 小弟在这先谢了，那位高手...
数据结构——栈和队列
奇蠢无比の二琦的博客
11-13 270
一、特殊线性表——栈 1.栈的逻辑结构 ①栈：限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的特殊操作：后进先出。 ②栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 ③栈的抽象数据类型定义 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStac...
"栈与队列的实现及习题练习【第4章-栈与队列1；第44章-栈与队列习题】
在本章的习题中，有一道题目是要求实现一个栈结构，可以使用列表模板类List来实现。通过仿照教材中由Vector类派生Stack类的方法，也可以通过由List类派生Stack类来实现这个栈结构。代码示例如下： ```cpp #include ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值