栈和队列操作的实现（验证性实验）

最新推荐文章于 2024-07-23 20:38:48 发布
最新推荐文章于 2024-07-23 20:38:48 发布
阅读量573 收藏 5
点赞数
分类专栏： 数据结构 中南大学 文章标签： 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51877075/article/details/120614058
版权

栈和队列操作的实现（验证性实验）

1. 需求分析

要求：
(1) 建立一个顺序栈。
(2) 建立一个循环顺序队列。
(3) 分别实现栈和队列的基本操作
分析：
（1) 输入的形式和输入值的范围：按照屏幕提示输入数个int型数字
（2) 输出的形式：各个功能输出对应数个int型数字。
（3) 程序所能达到的功能：栈的基本操作：创建栈，创建栈，清空栈，判断栈是否为空栈，求栈长度，取栈顶，入栈，出栈，遍历栈；队列的基本操作：创建队列，求队列长度，添加节点，删除节点，销毁队列，清空队列，判断队列是否为空，取队列顶部，队列遍历。
（4) 测试数据：
栈操作的实现：
· 依次输入数据：1 2 3 4 5 6 7 8 9 10；
· 输出结果显示在屏幕上；
队列操作的实现：
· 依次输入数据：1 2 3 4 5 6 7 8 9 10；
· 输出结果显示在屏幕上；
· 再依次输入数据：11 12 13；
· 输出结果显示在屏幕上。

2. 概要设计

  1. 为了实现程序功能，需要定义栈和队列的抽象数据类型。
ADT Stack {
      数据对象：
         D＝{ ai | ai ∈ElemSet, i=1,2,...,n,  n≥0 }
      数据关系：
         R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }
                   约定an 端为栈顶，a1 端为栈底。  
              typedef struct{                    
	              selemtype *base;                //尾指针 
	              selemtype *top;                 //头指针 
	              int stacksize;                  //栈长 
			  }sqstack;                           //栈结构
基本操作：
InitStack(&S)
   操作结果：构造一个空栈S
DestroyStack (&S)
    初始条件：栈S已存在
    操作结果：销毁栈S
                  ClearStack (&S)
                          初始条件：栈S已存在
                          操作结果：将栈置为空栈
                  StackEmpty(&S)
                          初始条件：栈S已存在
操作结果：若S为空栈则返回TRUE，否则返回FALSE 
StackLength(&S)
初始条件：栈S已存在
                        操作结果：返回S中数据元素的个数，即栈的长度
                GetTop(&S, &e)
初始条件：栈S已存在
                        操作结果：用e返回S的栈顶元素
                Push(&S, e)
初始条件：栈S已存在
                          操作结果：插入元素e为新的栈顶元素
                  Pop(&S, &e)
                          初始条件：栈S已存在且非空
                          操作结果：删除S的栈顶元素，并用e返回其值
StackTraverse(&S, visit())
                          初始条件：栈S已存在且非空
                          操作结果：从栈底到栈顶依次对S的每个数据元素调用函数visit()，一旦visit()失败，则操作失败
}ADT Stack

ADT Queue {
    数据对象：
               D＝{ai | ai∈ElemSet, i=1,2,...,n, n≥0}
    数据关系：
               R1＝{ <a i-1, ai > | ai-1, ai ∈D, i=2,...,n}
       约定其中a1 端为队列头，an 端为队列尾
    typedef struct{
	qelemtype *base;
	int front;
	int rear;
}sqqueue;                //队列结构
基本操作：
               InitQueue(&Q)
                           操作结果：构造一个空队列Q。
                   DestroyQueue(&Q)
                           初始条件：队列Q已存在。
                           操作结果：队列Q被销毁，不再存在。
                   QueueEmpty(Q)
                           初始条件：队列Q已存在。
                           操作结果：若Q为空队列，则返回TRUE，否则返回FALSE。
               QueueLength(Q)
                            初始条件：队列Q已存在。
                            操作结果：返回Q的元素个数，即队列的长度。 
GetHead(Q,&e)
                            初始条件：Q为非空队列。
                            操作结果：用e返回Q的队头元素。
ClearQueue(&Q)
                            初始条件：队列Q已存在。
                            操作结果：将Q清为空队列。 
                    EnQueue(&Q, e)
                            初始条件：队列Q已存在。
                            操作结果：插入元素e为Q的新的队尾元素
DeQueue(&Q, &e)
                            初始条件：Q为非空队列。
                            操作结果：删除Q的队头元素，并用e返回其值。
QueueTraverse(Q, visit())
        初始条件：队列Q存在且非空
        操作结果：从栈底到栈顶依次对S的每个数据元素调用函数visit()，一旦visit()失败，则操作失败
} ADT Queue

3.具体代码

  • 栈操作的实现：
#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 5 
#define STACKINCREMENT 10

#define selemtype int
#define TRUE 1
#define FLASE 0
#define OK 1
#define ERROR 0
 
typedef struct{                    
	selemtype *base;                //尾指针 
	selemtype *top;                 //头指针 
	int stacksize;                  //栈长 
}sqstack;                           //栈结构 

int visit(selemtype *e)             //打印节点 
{
	//输入的为指针 
	if(e == NULL)
	{
		//当指针指向null直接返回错误 
		return ERROR;
	}
	else
	{
		//否则打印指针指向的数据 
		printf("%d ",*e);
		return OK; 
	}
}

void initstack(sqstack *s);     //创建栈
void destroystack(sqstack *s);  //销毁栈
void clearstack(sqstack *s);    //清空栈 
int stackempty(sqstack s);      //判断栈是否为空栈 
int stacklength(sqstack s);      //求栈长度 
int gettop(sqstack s,selemtype *e);    //取栈顶
void push(sqstack *s,selemtype e);     //入栈
int pop(sqstack *s,selemtype *e);      //出栈 
int stacktraverse(sqstack s,int (*visit)(selemtype *e));  //遍历栈  

int main()
{   
  //  int a;
  	
	sqstack stack;//先定义结构体 
	initstack(&stack);//创建栈 
	printf("是否为空栈：%d",stackempty(stack));
	printf("\n请输入10个数：");
//	scanf("%d",&a);
	int i;
	int n = 0;
	for(;n < 10;n++)
	{
		scanf("%d",&i);//输入 
		push(&stack,i); //入栈 
	} 
	i=0;//使i重归0 
	printf("\n栈长度：%d",stacklength(stack));//输出栈的长度 
	gettop(stack,&i);//获取栈顶元素，存在i中 
	printf("\n栈顶元素：%d",i);//输出栈顶元素 
	printf("\n删除顶部3个元素:");
	n = 0;
	for(;n < 3;n++)
	{
		pop(&stack,&i);//弹出栈顶元素 
		printf("%d ",i);//输出删除的栈顶元素 
	}
	printf("\n遍历栈");
	stacktraverse(stack,visit);
	printf("\n是否为空栈：%d",stackempty(stack));//判断是否为空栈 
	printf("\n清空栈");
	clearstack(&stack);//清空 
	printf("\n是否为空栈：%d",stackempty(stack));//判断是否为空栈 
	destroystack(&stack);//销毁 
	if(stack.base == NULL&&stack.top ==NULL&&stack.stacksize ==0)
	{
		printf("\n销毁栈成功。");
	}
	return 0;
} 
void initstack(sqstack *s)                                     //创建栈 
{
	s->base = (selemtype*)malloc(STACK_INIT_SIZE*sizeof(int));// 为栈底部创空间 
	s->top = s->base;//初始，栈顶等于栈底 
	s->stacksize = STACK_INIT_SIZE;//栈长度为5
}
void destroystack(sqstack *s)                                 //销毁栈 
{
	free(s->base);//释放base空间 
	s->base = NULL;
	s->top = NULL;
	s->stacksize = 0;//使长度为0 
}
void clearstack(sqstack *s)                                  //清空栈 
{
	s->base = (selemtype*)malloc(s->stacksize*sizeof(int));
	s->top = s->base;
	//相当于重新初始化设置 
}
int stackempty(sqstack s)                                    //判断栈是否为空栈 
{
	if(s.base == s.top&&s.top != NULL)//顶部和底部位置相同，且不为空 
	{
		return TRUE;
	}
	else 
	{
		return FLASE;
	}
}
int stacklength(sqstack s)                                  //求栈长度 
{
	selemtype *p=s.base;//p指向栈底元素 
	int n=0;//用于for循环 
	for(;p != s.top||n >= s.stacksize;p++)
	{
		n++;
	}
	return n;//返回栈长度 
}
int gettop(sqstack s,selemtype *e)                        //取栈顶 
{
	if(s.top == s.base)//如果栈顶=栈底，则栈为空 
	{
		return ERROR;
	}
	else
	{
		*e = *(s.top-1);
		return OK;
	}
}
void push(sqstack *s,selemtype e)                       //入栈 
{
	if((stacklength(*s)+1) >= s->stacksize)
	{
		s->base = (selemtype*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(selemtype));
		s->stacksize += STACKINCREMENT;//入栈10个元素 
		s->top =s->base+s->stacksize-STACKINCREMENT-1;
	}
	*s->top = e;//先存放元素 
	s->top++;//再让top位置往后移 
}
int pop(sqstack *s,selemtype *e)                      //出栈 
{
	if(stackempty(*s) != TRUE)
	{
		*e = *(--s->top);
		return OK;
	}
	else
	{
		return ERROR;
	}
}
int stacktraverse(sqstack s,int (*visit)(selemtype *e))     //遍历栈 
{
	selemtype *p = s.base;
	for(;p != s.top;p++)
	{
		if(!visit(p))
		{
			return ERROR;
		}
	}
	return OK;
}
  • 队列操作的实现：
#include<stdio.h> 
#include<stdlib.h>

#define MAXQSIZE 11
#define qelemtype int
#define OVERFLOW -1
#define OK 1
#define ERROR 0

typedef struct{
	qelemtype *base;//队列（指针型数组） 
	int front;//头 
	int rear;//尾 
}sqqueue;                //队列结构 

int visit(qelemtype e)     //打印节点 
{
	if(printf("%d ",e))
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}

void initqueue(sqqueue *q);             //创建队列 
int queuelength(sqqueue q);             //求队列长度 
int enqueue(sqqueue *q,qelemtype e);    //添加节点
int dequeue(sqqueue *q,qelemtype *e);   //删除节点
void destroyqueue(sqqueue *q);           //销毁队列 
int clearqueue(sqqueue *q);             //清空队列 
int queueempty(sqqueue q);              //判断队列是否为空
int gethead(sqqueue q,qelemtype *e);     //取队列顶部
int queuetraverse(sqqueue q,int (*visit)(qelemtype e));     //队列遍历 

int main()
{
	
	sqqueue queue;//定义队列 
	initqueue(&queue);//初始化队列 
	printf("队列长度：%d",queuelength(queue));//求队列长度 
	printf("是否为空队列：%d",queueempty(queue));//判断是否为空队列 
	printf("\n请输入10个数：");//往队列中放置10个数字 
	int i;//用于储存输入量 
	int n = 0;//用于for循环 
	for(;n < 10;n++)
	{
		scanf("%d",&i);
		enqueue(&queue,i); //将输入量置入队列 
	} 
	i=0;//将i重新设置为0 
	printf("\n队列长度：%d",queuelength(queue));//再求队列长度 
	gethead(queue,&i);//取出队列头 
	printf("\n队头元素：%d",i);//输出队头元素 
	printf("\n删除队头3个元素:");//删除3个元素 
	n = 0;
	for(;n < 3;n++)
	{
		dequeue(&queue,&i);//出队3次 
		printf("%d ",i);//同时输出元素 
	}
	printf("\n遍历队列");//遍历 
	queuetraverse(queue,visit);
	printf("\n请输入3个数：");
	n = 0;
	for(;n < 3;n++)
	{
		scanf("%d",&i);//i为输入的读取 
		enqueue(&queue,i); //再次添加节点 
	} 
	printf("\n遍历队列");
	queuetraverse(queue,visit);
	printf("是否为空队列：%d",queueempty(queue));//判断是否为空队列 
	printf("\n清空队列");
	clearqueue(&queue);//清空 
	printf("\n是否为空队列：%d",queueempty(queue));
	destroyqueue(&queue);
	if(queue.base == NULL&&queue.front == 0&&queue.rear == 0)
	{
		printf("\n销毁栈成功。");
	}
	return 0;
}

void initqueue(sqqueue *q)           //创建队列 
{
	q->base = (qelemtype *)malloc(MAXQSIZE*sizeof(qelemtype));//分配空间 
	if(!q->base)
	{
		exit(OVERFLOW);
	} 
	q->front = q->rear = 0;//初始收尾都是0 
}
int queuelength(sqqueue q)            //求队列长度 
{
	return (q.rear - q.front + MAXQSIZE) % MAXQSIZE;//循环队列求队列长度的公式 
}
int enqueue(sqqueue *q,qelemtype e)    //添加节点 
{
	if((q->rear + 1) % MAXQSIZE == q->front)//判断是否队列满 
	{
		return(ERROR);
	}
	q->base[q->rear] = e;//如果队列未满，则将数据添加进去 
	q->rear = (q->rear + 1) % MAXQSIZE;//尾节点后移 
	return OK;
}
int dequeue(sqqueue *q,qelemtype *e)    //删除节点 
{
	if(q->front == q->rear)//如果为空队列 
	{
		return ERROR;
	}
	*e = q->base[q->front];//保存删除节点的e的数据 
	q->front = (q->front + 1) % MAXQSIZE;//头部位置后移 
	return OK;
}
void destroyqueue(sqqueue *q)         //销毁队列 
{
	free(q->base);//清除空间 
	q->base =NULL;//数组置为空 
	q->front = q->rear =0;//重新初始化为0 
}
int clearqueue(sqqueue *q)         //清空队列 
{
	if(q)//若数组非空 
	{
		q->front = q->rear = 0;//只需要让头尾指针重新置0即可 
		return OK; 
	}
	else
	{
	    return ERROR; 
	}
}
int queueempty(sqqueue q)      //判断队列是否为空 
{
	if(q.front == q.rear)
	{
		return OK;
	}
	else 
	{
		return ERROR;
	}
}
int gethead(sqqueue q,qelemtype *e)     //取队列顶部 
{
	if(!queueempty(q))
	{
		*e = q.base[q.front];//获取队列顶部元素 ，用e储存 
		return OK;
	}
	else
	{
		return ERROR;
	}
}
int queuetraverse(sqqueue q,int (*visit)(qelemtype e))   //队列遍历 
{
	int i = q.front;//首先令i为队列头指针的位置 
	for(;i != q.rear;i++)//遍历队列 
	{
		if(!visit(q.base[i]))//利用visit函数 
		{
			return ERROR;
		}
		if(i >= (MAXQSIZE-1))//对于循环队列而言，到达数组底部还未遍历完的话，重新回到队列头部 
		{
			i = -1;
		}
		
	}
	return OK;
}
新参者-tangent
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验二栈和队列
qq_57611608的博客
06-04 3686
实验二 栈和队列 一、实验目的和要求 1、理解栈的存储结构及基本操作实现。 2、掌握应用栈解决问题的方法。 3、掌握队列的存储结构及基本操作实现，并能在相应的应用问题中正确选用它们。 二、实验仪器和设备 微型计算机 三、实验内容与过程 1、验证性实验：实现顺序栈的基本操作 实验内容：编写一个程序sqstack.cpp (或.c)，实现顺序栈的各种基本运算（假设栈中元素类型SElemType为char），并在此基础上设计一个程序exp3-1.cpp (或.c)完成以下功能。 (1) 初..
c语言栈和队列实验报告,数据结构与算法实验报告栈
weixin_42500616的博客
05-18 1745
数据结构与算法实验报告栈Tag内容描述：1、实验二 栈和队列实现四则运算 一、实验目的及要求： 1、掌握栈和队列的基本操作：建立、插入、删除、查找、合并 2、掌握用栈和队列的储存 3、熟悉C语言上机编程环境 4、掌握编译、调试程序的方法 二、实验内容： 采用栈进行表达式的求值，表达式求值是程序设计语言编译中的一个最基本问题。它的实现是栈应用的又一个典型例子，本报告使用的是“算符优先法”求表达式的值...
实验三 栈和队列的操作
Stonesaul的博客
10-11 1805
1．验证性实验2．（1）编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈。（2）编程实现队列的以下基本操作：建队列，取队头元素，入队，出队。3．（1）掌握栈的顺序存储结构、链式存储结构及其基本操作；（2）掌握队列的顺序存储结构、链式存储结构及其基本操作。
数据结构实验三——栈和队列的基本操作
weiyuexin的博客
10-11 5777
** 一、实验内容 ** 1. 实验目的 编程实现顺序栈和链栈的基本操作：建栈，取栈顶元素，入栈，出栈； 编程实现循环队列和链队列的基本操作：建队列，取队头元素，入队，出队。 2. 基本要求 掌握栈的顺序存储结构、链式存储结构及其基本操作； 掌握队列的顺序存储结构、链式存储结构及其基本操作。 4. 支撑的课程目标 本实验项目可以支撑“目标1. 理解数据结构的基本概念、计算机内部数据对象的表示和特性。掌握线性表、树、图等数据逻辑结构、存储结构及其差异以及各种操作的实现。”、和“目标2能够针对实际问题选
数据结构实验报告二 栈和队列
G_M_R_的博客
12-31 6760
数据结构实验报告：实验二 栈和队列
栈和队列实验：数制转换和括号匹配
m0_60284156的博客
10-08 1318
当计算机接受了第1个括号以后，它期待着与其匹配的第8个括号的出现，然而等来的却是第2个括号，此时第1个括号“[”只能暂时靠边，而迫切等待与第2个括号相匹配的第7个括号“）”的出现，类似的，因只等来了第3个括号“[”，此时，其期待的紧迫程度较第2个括号更紧迫，则第2个括号只能靠边，让位于第3个括号，显然第3个括号的期待紧迫程度高于第2个括号，而第2个括号的期待紧迫程度高于第1个括号；在接受了第4个括号之后，第3个括号的期待得到了满足，消解之后，第2个括号的期待匹配就成了最急迫的任务了，……
栈和队列（c语言数据结构实验报告二）
库蒂尼奥的博客
06-27 3755
实验项目中文名称：栈与队列 实验项目英文名称：Stack and queue 实验教学的内容或要求 1.编写函数,采用链式存储实现栈的初始化、入栈、出栈操作 2.编写函数,采用顺序存储实现栈的初始化、入栈、出栈操作 3.编写函数,采用链式存储实现队列的初始化、入队、出队操作 4.编写函数,采用顺序存储实现队列的初始化、入队、出队操作 5.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法 #include<stdio.h> #include<windows.h> #pra
《数据结构》实验报告三：栈 队列
热门推荐
Amentos的博客
10-05 1万+
《数据结构》实验报告：栈和队列相关概念 + 入栈/出栈算法实现 + 十进制转二进制算法实现 + 只含一个尾指针的循环链队入队/出队算法代码
《数据结构》上机实验(第三章)——栈和队列 Ⅰ
Miss Z的博客
08-07 3230
1. 利用顺序栈判断一个字符串是否为对称串。 算法思想：对于字符串str，从头到尾将其所有元素连续进栈，如果所有元素连续出栈产生的序列和str从头到尾的字符依次相同，表示str是一个对称串，返回真；否则表示str不是对称串，返回假 bool Symmtry(ElemType str[]) //判断str是否为对称串 { int i; ElemType e; SqStack* st; //定义顺序栈指针 InitStack(st); //初始化栈 for (i = 0; str[i] !=
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。输入字符#，执行一次出队操作，...要求采用队头/队尾间隔至少一个空闲元素的方法来实现循环队列；空队执行出队操作及队满执行入队操作需显示提示信息。
[栈及队列的操作]数据结构实验报告C语言源码
07-05
### 数据结构实验报告——栈及队列的操作 #### 实验目的和要求 本次实验旨在让学生通过实际编程操作熟练掌握栈及队列这两种重要的线性数据结构。具体目标如下： 1. **栈**: 理解栈的基本概念及其“后进先出”（LIFO...
栈和队列的基本操作的实现.
03-06
在实验内容部分，学生需要实现栈和队列的各个操作，并在每一步之后输出当前的数据结构状态，以便于观察和验证操作的正确性。这不仅锻炼了编程技能，也加深了对数据结构特性的理解。 总的来说，这个实验是学习数据...
数据结构实验报告《二、栈和队列的运用》
11-29
关键函数如`pops`、`popq`、`push`和`push_back`分别实现了栈和队列的基本操作，如出栈、出队、入栈和入队。 通过以上详尽的设计思路和实验步骤，学生可以深入理解栈和队列的工作原理，并掌握其实现方法，为进一步...
数据结构实验报告+栈和队列.docx
11-12
通过这些测试，我们可以验证这些数据结构的正确性和效率，如检查栈的空状态、栈顶元素获取、元素入栈和出栈，以及队列的入队、出队和获取队头元素等功能。 实验结果表明，设计的栈和队列数据结构能够正确执行预期的...
c语言（7.23）
fhgfyrsg的博客
07-23 425
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 776
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
最新发布
qq_35320456的博客
07-23 391
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 361
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值