链栈顺序栈实验报告
栈的实验报告结论(3篇)
第1篇一、实验目的1. 理解栈的基本概念和操作;2. 掌握栈的顺序存储和链式存储实现方法;3. 熟悉栈在程序设计中的应用。
二、实验内容1. 栈的顺序存储结构实现;2. 栈的链式存储结构实现;3. 栈的基本操作(入栈、出栈、判空、求栈顶元素);4. 栈在程序设计中的应用。
三、实验方法1. 采用C语言进行编程实现;2. 对实验内容进行逐步分析,编写相应的函数和程序代码;3. 通过运行程序验证实验结果。
四、实验步骤1. 实现栈的顺序存储结构;(1)定义栈的结构体;(2)编写初始化栈的函数;(3)编写入栈、出栈、判空、求栈顶元素的函数;(4)编写测试程序,验证顺序存储结构的栈操作。
2. 实现栈的链式存储结构;(1)定义栈的节点结构体;(2)编写初始化栈的函数;(3)编写入栈、出栈、判空、求栈顶元素的函数;(4)编写测试程序,验证链式存储结构的栈操作。
3. 栈在程序设计中的应用;(1)实现一个简单的四则运算器,使用栈进行运算符和操作数的存储;(2)实现一个逆序输出字符串的程序,使用栈进行字符的存储和输出;(3)编写测试程序,验证栈在程序设计中的应用。
五、实验结果与分析1. 顺序存储结构的栈操作实验结果:(1)入栈操作:在栈未满的情况下,入栈操作成功,栈顶元素增加;(2)出栈操作:在栈非空的情况下,出栈操作成功,栈顶元素减少;(3)判空操作:栈为空时,判空操作返回真,栈非空时返回假;(4)求栈顶元素操作:在栈非空的情况下,成功获取栈顶元素。
2. 链式存储结构的栈操作实验结果:(1)入栈操作:在栈未满的情况下,入栈操作成功,链表头指针指向新节点;(2)出栈操作:在栈非空的情况下,出栈操作成功,链表头指针指向下一个节点;(3)判空操作:栈为空时,判空操作返回真,栈非空时返回假;(4)求栈顶元素操作:在栈非空的情况下,成功获取栈顶元素。
3. 栈在程序设计中的应用实验结果:(1)四则运算器:成功实现加、减、乘、除运算,并输出结果;(2)逆序输出字符串:成功将字符串逆序输出;(3)测试程序:验证了栈在程序设计中的应用。
顺序栈实验报告
顺序栈实验报告1. 实验目的本实验旨在通过实现顺序栈的基本操作,加深对栈的理解,并学习如何使用顺序栈解决实际问题。
2. 实验内容本实验包含以下内容:1.实现栈的初始化操作,并判断栈是否为空;2.实现入栈操作,将元素插入栈顶;3.实现出栈操作,将栈顶元素删除,并返回删除的元素;4.实现获取栈顶元素的操作,不改变栈的结构;5.实现获取栈的长度操作。
3. 实验步骤3.1 栈的初始化首先,我们需要定义一个顺序栈的结构体,其中包括栈的容量、栈顶指针和存放元素的数组。
栈的容量可以根据实际需要进行调整,栈顶指针初始值为-1。
#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SqStack;然后,我们可以编写初始化栈的函数:void InitStack(SqStack *s) {s->top = -1;}3.2 判断栈是否为空我们可以通过栈顶指针的值是否等于-1来判断栈是否为空,编写如下函数:int IsEmpty(SqStack *s) {if (s->top == -1) {return1;} else {return0;}}3.3 入栈操作入栈操作即将元素插入栈顶。
在插入元素前,我们需要判断栈是否已满。
若栈未满,则将元素插入栈顶,并更新栈顶指针的值。
编写如下函数:int Push(SqStack *s, int x) {if (s->top == MAX_SIZE - 1) {return0; // 栈满,插入失败} else {s->top++;s->data[s->top] = x;return1; // 插入成功}}3.4 出栈操作出栈操作即将栈顶元素删除,并返回删除的元素。
在删除元素前,我们需要判断栈是否为空。
若栈不为空,则将栈顶元素删除,并更新栈顶指针的值。
编写如下函数:int Pop(SqStack *s, int *x) {if (IsEmpty(s)) {return0; // 栈空,删除失败} else {*x = s->data[s->top];s->top--;return1; // 删除成功}}3.5 获取栈顶元素获取栈顶元素不改变栈的结构,只需要返回栈顶指针对应的元素即可。
栈的获取实验报告(3篇)
第1篇一、实验目的1. 理解栈的基本概念和特点。
2. 掌握栈的顺序存储结构和链式存储结构。
3. 熟悉栈的基本操作,包括入栈、出栈、判断栈空等。
4. 通过实验,加深对栈在计算机科学中的应用理解。
二、实验内容1. 实现栈的顺序存储结构,包括初始化、入栈、出栈、判断栈空等操作。
2. 实现栈的链式存储结构,包括初始化、入栈、出栈、判断栈空等操作。
3. 设计并实现一个递归算法,求解斐波那契数列的前n项。
4. 设计并实现一个算法,判断一个字符串是否为回文。
三、实验步骤1. 实现栈的顺序存储结构(1)定义栈的结构体,包含栈的最大容量、栈顶指针、栈底指针、栈元素数组等。
(2)编写栈的初始化函数,初始化栈的最大容量、栈顶指针和栈底指针。
(3)编写入栈函数,判断栈是否已满,若未满则将元素压入栈顶。
(4)编写出栈函数,判断栈是否为空,若不为空则将栈顶元素弹出。
(5)编写判断栈空函数,判断栈顶指针是否等于栈底指针。
2. 实现栈的链式存储结构(1)定义栈的节点结构体,包含数据域和指针域。
(2)编写栈的初始化函数,初始化栈头节点。
(3)编写入栈函数,判断栈是否已满,若未满则创建新节点并插入链表头部。
(4)编写出栈函数,判断栈是否为空,若不为空则删除链表头部节点。
(5)编写判断栈空函数,判断栈头节点是否为空。
3. 实现递归算法求解斐波那契数列(1)编写递归函数,计算斐波那契数列的第n项。
(2)调用递归函数,计算斐波那契数列的前n项。
4. 实现判断字符串是否为回文的算法(1)编写一个辅助函数,判断两个字符串是否相等。
(2)将字符串逆序,并判断逆序后的字符串是否与原字符串相等。
四、实验结果与分析1. 顺序栈的实验结果通过实现顺序栈,我们成功完成了初始化、入栈、出栈、判断栈空等操作。
实验结果表明,顺序栈在空间利用上较为高效,但在插入和删除操作时,需要移动栈中元素,时间复杂度为O(n)。
2. 链栈的实验结果通过实现链栈,我们成功完成了初始化、入栈、出栈、判断栈空等操作。
栈-队列的顺序-链式储存结构(数据结构试验报告)
数据结构实验报告班级:计学号:姓名:设计日期:西安计算机学院实验题目1)栈的顺序存储结构2)栈的链式存储结构3)队列的链式存储结构4)队列的循环存储结构2.需求分析本演示程序用C语言编写,完成栈和列的初始化,入栈、出栈、输出操作。
1)对于顺序栈,入栈时要先判断栈是否满了,栈满不能入栈,否则出现空间溢出;在进栈出栈和读取栈顶时先判栈是否为空,为空时不能操作。
2)在一个链队表中需设定两个指针分别指向队列的头和尾。
3)队列的存储结构:注意要判断队满和队空。
4)程序所能达到的功能:完成栈的初始化,入栈,出栈和输出操作;完成队列的初始化,入队列,出队列和输出操作。
3.概要设计本程序包含1、栈的顺序存储结构包含的函数:1)主函数main()2)入栈函数Push()3)出栈函数Pop()2、栈的链式存储结构包含的函数:1)主函数main()2)入栈函数PushStack()3)退栈函数PopStack()4)取栈顶元素函数Getstack top()3、队列的链式存储结构所包含的函数:1)主函数main()2)入队函数EnQueue()3)出队函数DeQueue()4 队列的循环所包含的函数:1)主函数main()2)初始化循环函数CircSeqQueue()3)入队函数EnQueue()4)出队函数DeQueue()5)取队首元素函数GetFront()4.详细设计1)栈的顺序存储结构#include<stdio.h>#include<stdlib.h>#include<conio.h>#define MAXSIZE 20typedef int datatype;typedef struct{ datatype elem[MAXSIZE];int top;}SeqStack;int init(SeqStack *s){ s->top=-1; return 1;}void print(SeqStack *s){char ch; int i;if(s->top==-1)printf("\n 栈已空.");else{i=s->top;while(i!=-1){printf("\n data=%d",s->elem[i]); i--;}}printf("\n 按回车继续");ch=getch();}void push(SeqStack *s,datatype x){if(s->top==MAXSIZE-1) printf("\n 栈已满!");else s->elem[++s->top]=x;}datatype pop(SeqStack*s){datatype x;if(s->top==-1){printf("\n 栈已空! "); x=-1;}else{x=s->elem[s->top--];}return(x);}void main(){SeqStack s; int k; datatype x;if(init(&s)){do {printf("\n\n\n");printf("\n***************************************");printf("\n\n 1. x进栈");printf("\n\n 2.出栈返回其值");printf("\n\n 3 结束");printf("\n***************************************");printf("\n 请选择(123)");scanf("%d",&k);switch(k){case 1:{printf("\n 请输入进栈整数X=?");scanf("%d",&x);push(&s,x);print(&s);}break;case 2:{ x=pop(&s);printf("\n 出栈元素:%d",x);print(&s);}break;case 3:exit(0);}printf("n---------");}while(k>=1 &&k<3);printf("\n 按回车返回");getch();}elseprintf("\n 初始化失败!\n");}2).栈的链式存储结构#include<stdio.h>#include<stdlib.h>typedef struct SNode{int data;struct SNode*next;}SNode,*LinkStack;LinkStack top;LinkStack PushStack(LinkStack top,int x)//入栈{LinkStack s;s=(LinkStack)malloc(sizeof(SNode));s->data=x;s->next=top;top=s;return top;}LinkStack PopStack(LinkStack top) //退栈{LinkStack p;if(top!=NULL){p=top;top=top->next;free(p);printf("退栈已完成\n");return top;}elseprintf("栈是空的,无法退栈!\n");return 0;}int GetStackTop(LinkStack top) //取栈顶元素{return top->data;}bool IsEmpty(){return top==NULL?true:false;}void Print(){SNode*p;p=top;if(IsEmpty()){printf("The stack is empty!\n");return;}while(p){printf("%d ",p->data);p=p->next;}printf("\n");}void main(){int x,a,b;char m;do{printf("\n");printf(" 链栈的基本操作\n");printf(" \n");printf(" 1.置空栈\n");printf(" 2.进栈\n");printf(" 3.退栈\n");printf(" 4.取栈顶元素\n");printf(" 5.退出程序\n");printf("\n 请选择一个数字(1 2 3 4 5):");scanf("%c",&m);switch(m){case '1':{top=NULL;printf("\n栈已置空!");break;}case '2':{printf("请输入要进栈的元素个数是:");scanf("%d",&a);printf("\n请输入要进栈的%d个元素:",a);for(b=0;b<a;b++){scanf("%d",&x);top=PushStack(top,x);}printf("进栈已完成!\n");printf("\n输出栈为:");Print();}break;case '3':{printf("\n操作之前的输出栈为:");Print();top=PopStack(top);printf("\n操作过后的输出栈为:");Print();}break;case '4':{printf("\n输出栈为:");Print();if(top!=NULL)printf("\n栈顶元素是:%d\n",GetStackTop(top));elseprintf("\n栈是空的,没有元素!");}break;case '5':break;default:printf("\n输入的字符不对,请重新输入!");break;}getchar();}while(m!='5'); }运算结果:3)队列的链式存储结构#include<stdio.h>#include<stdlib.h>#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<math.h>typedef int dataType;typedef struct node{ dataType data;struct node *next;}QNode;typedef struct{QNode *front,*rear;}LQueue;/*初始化*/int init(LQueue *q){if((q->front=(QNode *)malloc(sizeof(QNode)))==NULL) return 0;q->rear=q->front;q->front->next=NULL;return 1;}/*出队*/void print(LQueue Q){ QNode *p; char ch;p=Q.front->next;while(p!=NULL){printf("\n%d",p->data); p=p->next; } printf("\n 按回车键继续。
栈及其应用实验报告
一、实验目的1. 理解栈的定义、特点、逻辑结构及其在计算机科学中的应用。
2. 掌握顺序栈和链栈的存储结构及基本操作实现。
3. 通过具体应用实例,加深对栈的理解,提高问题分析和解决的能力。
二、实验内容1. 实现顺序栈和链栈的基本操作。
2. 编写一个算法,判断给定的字符序列是否为回文。
3. 编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。
4. 给定一个整数序列,实现一个求解其中最大值的递归算法。
三、实验步骤1. 实现顺序栈和链栈的基本操作(1)顺序栈的存储结构及操作实现顺序栈使用数组来实现,其基本操作包括:- 初始化栈:使用数组创建一个空栈,并设置栈的最大容量。
- 入栈:将元素插入栈顶,如果栈满,则返回错误。
- 出栈:从栈顶删除元素,如果栈空,则返回错误。
- 获取栈顶元素:返回栈顶元素,但不删除。
- 判断栈空:判断栈是否为空。
(2)链栈的存储结构及操作实现链栈使用链表来实现,其基本操作包括:- 初始化栈:创建一个空链表,作为栈的存储结构。
- 入栈:在链表头部插入元素,如果链表为空,则创建第一个节点。
- 出栈:删除链表头部节点,如果链表为空,则返回错误。
- 获取栈顶元素:返回链表头部节点的数据。
- 判断栈空:判断链表是否为空。
2. 判断字符序列是否为回文编写一个算法,判断给定的字符序列是否为回文。
算法步骤如下:(1)使用顺序栈或链栈存储字符序列。
(2)从字符序列的头部开始,依次将字符入栈。
(3)从字符序列的尾部开始,依次将字符出栈,并与栈顶元素比较。
(4)如果所有字符均与栈顶元素相等,则字符序列为回文。
3. 利用栈的基本运算将指定栈中的内容进行逆转编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。
算法步骤如下:(1)创建一个空栈,用于存储逆转后的栈内容。
(2)从原栈中依次将元素出栈,并依次入新栈。
(3)将新栈的内容赋值回原栈,实现栈内容的逆转。
4. 求解整数序列中的最大值给定一个整数序列,实现一个求解其中最大值的递归算法。
栈的建立实验报告
一、实验目的本次实验旨在通过编程实现栈的顺序存储结构和链式存储结构,并熟练掌握栈的基本操作,包括栈的建立、入栈、出栈、取栈顶元素、判栈空等。
通过实验,加深对栈这一数据结构的理解,提高数据结构在实际问题中的应用能力。
二、实验内容1. 顺序栈的建立与基本操作(1)顺序栈的建立顺序栈使用一维数组来实现,其大小为栈的最大容量。
在建立顺序栈时,需要初始化栈顶指针top为-1,表示栈为空。
(2)顺序栈的基本操作① 入栈操作(Push)当栈未满时,将新元素插入到栈顶,同时栈顶指针top加1。
② 出栈操作(Pop)当栈非空时,将栈顶元素出栈,同时栈顶指针top减1。
③ 取栈顶元素操作(GetTop)当栈非空时,返回栈顶元素。
④ 判栈空操作(IsEmpty)当栈顶指针top为-1时,表示栈为空。
2. 链式栈的建立与基本操作(1)链式栈的建立链式栈使用链表来实现,每个节点包含数据域和指针域。
在建立链式栈时,需要创建一个头节点,其指针域为空。
(2)链式栈的基本操作① 入栈操作(Push)当栈为空时,创建新节点作为栈顶节点;当栈非空时,将新节点插入到头节点的下一个节点,同时修改头节点的指针域。
② 出栈操作(Pop)当栈非空时,删除头节点的下一个节点,同时修改头节点的指针域。
③ 取栈顶元素操作(GetTop)当栈非空时,返回头节点的下一个节点的数据域。
④ 判栈空操作(IsEmpty)当头节点的指针域为空时,表示栈为空。
三、实验步骤1. 编写顺序栈和链式栈的建立函数。
2. 编写顺序栈和链式栈的基本操作函数。
3. 编写测试程序,验证顺序栈和链式栈的基本操作。
四、实验结果与分析1. 顺序栈实验结果通过编写顺序栈的建立和基本操作函数,成功实现了顺序栈的入栈、出栈、取栈顶元素、判栈空等操作。
在测试程序中,依次进行入栈、出栈、取栈顶元素等操作,均能正确执行。
2. 链式栈实验结果通过编写链式栈的建立和基本操作函数,成功实现了链式栈的入栈、出栈、取栈顶元素、判栈空等操作。
链栈顺序栈实验报告
第五次实验报告——顺序栈、链栈的插入和删除一需求分析1、在演示程序中,出现的元素以数字出现定义为int型,2、演示程序在计算机终端上,用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在终端上3、顺序栈的程序执行的命令包括如下:(1)定义结构体(2)顺序栈的初始化及创建(3)元素的插入(4)元素的删除(5)顺序栈的打印结果3、链栈的程序执行的命令包括如下:(1)定义结构体(2)链栈的初始化及创建(3)元素的插入(4)元素的删除(5)链栈的打印结果二概要设计1、顺序栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n }基本操作:InitStack(SqStack &S)操作结果:构造一个空栈Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;2、链栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n } 基本操作:LinkStack(SqStack &S)操作结果:构造一个空栈Status Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;3、顺序栈程序包含的主要模块:(1) 已给定的函数库:(2)顺序栈结构体:(3)顺序栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:4、链栈程序包含的主要模块:(1) 已给定的函数库:(2)链栈结构体:(3)链栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:三详细设计线性栈:结构体#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{int *base;//在构造栈之前和销毁之后,base的值为NULL int *top;//栈顶指针int stacksize;//当前已分配的存储空间,以元素为单位}SqStack#include"Base.h"主函数#include"construction.h"#include"stack_operation.c"int main(){SqStack S;int choice,e;S=InitStack();S=Input_Sq(S);printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行入栈操作后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法");}}线性栈的创建SqStack InitStack()//线性栈的创建{SqStack S;S.base=(int*)malloc(STACK_INIT_SIZE * sizeof(int));//分配存储空间if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return S;}输入函数SqStack Input_Sq(SqStack S)//输入函数{int n,i;printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个元素",n);for(i=0;i<n;i++){scanf("%d",S.top);S.top++;}return S;}进栈函数SqStack Push(SqStack S,int e)//进栈函数{if(S.top-S.base>=S.stacksize)//判断栈是否为满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;//插入元素return S;}出栈函数SqStack Pop(SqStack S)//删除函数{int e;if(S.top==S.base)printf("线性栈为空");e=*--S.top;return S;}输出函数void Print_Stack(SqStack S)//打印函数{int i;while(S.base!=S.top){for(i=0;i<S.top-S.base;i++){S.top--;printf("%5d",*S.top);}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */ #include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl链栈程序:结构体typedef struct SNode//建立链表结构体{int data;struct SNode *next;}SNode,*LinkStack;主函数#include"Base.h"#include"construction.h"#include"LinkStack_operation.c"int main(){LinkStack S;int choice,e;S=Creatlist_Stack();printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行操作入栈后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法\n");}}创建链栈函数LinkStack Creatlist_Stack()//创建一个链栈{LinkStack S;LinkStack P;int i,n;S=(LinkStack)malloc(sizeof(SNode));S->next=NULL;/* 先建立一个链栈 */printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个数据\n",n);i=0;scanf("%d",&S->data);for(i=1;i<n;++i){P=(LinkStack)malloc(sizeof(SNode)); /* 生成新结点 */P->next=S;S=P;scanf("%d",&S->data); /* 输入元素值 */}return S;}入栈函数LinkStack Push(LinkStack S,int e){LinkStack P;if(S==NULL)return ERROR;P=(LinkStack)malloc(sizeof(SNode));P->data=e;P->next=S;S=P;return S;}出栈函数LinkStack Pop(LinkStack S){LinkStack P,Q;P=S;S=S->next;free(P);return S;}输出函数void Print_Stack(LinkStack S){while(S){printf("%5d",S->data);S=S->next;}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl四调试分析:输出函数用了语句S->next!=NULL改正:语句S!=NULL五用户手册:看提示内容六测试结果线性栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1链栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1。
数据结构实验报告顺序栈
数据结构实验报告顺序栈一、实验目的本次实验的主要目的是深入理解和掌握顺序栈这种数据结构的基本概念、操作原理以及在实际编程中的应用。
通过实际编写代码和进行实验操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程环境是Visual Studio 2019,编程语言为C++。
三、顺序栈的概念顺序栈是一种线性数据结构,它是基于数组实现的。
顺序栈遵循“后进先出”(Last In First Out,LIFO)的原则,即最后入栈的元素最先出栈。
顺序栈需要预先分配一块连续的存储空间来存储栈中的元素。
在操作过程中,通过一个栈顶指针来指示当前栈顶的位置。
当进行入栈操作时,如果栈未满,则将新元素添加到栈顶指针所指的位置,并将栈顶指针向上移动一位;当进行出栈操作时,如果栈非空,则取出栈顶元素,并将栈顶指针向下移动一位。
四、顺序栈的操作(一)初始化操作```cpptypedef struct {int data;int top;int capacity;} SeqStack;void initStack(SeqStack &s, int capacity) {sdata = new intcapacity;stop =-1;scapacity = capacity;}```在初始化函数中,为顺序栈分配指定大小的存储空间,并将栈顶指针初始化为-1,表示栈为空。
(二)入栈操作```cppbool push(SeqStack &s, int x) {if (stop == scapacity 1) {return false;}sdata++stop = x;return true;}```入栈操作首先检查栈是否已满,如果未满,则将新元素添加到栈顶,并更新栈顶指针。
(三)出栈操作```cppbool pop(SeqStack &s, int &x) {if (stop ==-1) {return false;}x = sdatastop;return true;}```出栈操作首先检查栈是否为空,如果非空,则取出栈顶元素,并更新栈顶指针。
栈的基本操作实验报告
一、实验目的1. 掌握栈的定义、特点、逻辑结构,理解栈的抽象数据类型。
2. 熟练掌握顺序栈和链栈两种结构类型的定义、特点以及基本操作的实现方法。
3. 了解栈在解决实际问题中的应用。
二、实验内容1. 编写顺序栈和链栈的基本操作函数,包括入栈(push)、出栈(pop)、判断栈空(isEmpty)、获取栈顶元素(getTop)等。
2. 利用栈实现字符序列是否为回文的判断。
3. 利用栈实现整数序列中最大值的求解。
三、实验步骤1. 创建顺序栈和链栈的结构体,并实现相关的基本操作函数。
2. 编写一个函数,用于判断字符序列是否为回文。
该函数首先将字符序列中的字符依次入栈,然后逐个出栈,比较出栈的字符是否与原序列相同,若相同则表示为回文。
3. 编写一个函数,用于求解整数序列中的最大值。
该函数首先将序列中的元素依次入栈,然后逐个出栈,每次出栈时判断是否为当前栈中的最大值,并记录下来。
四、实验结果与分析1. 顺序栈和链栈的基本操作函数实现如下:```c// 顺序栈的基本操作void pushSeqStack(SeqStack s, ElemType x) {if (s->top < MAXSIZE - 1) {s->top++;s->data[s->top] = x;}}void popSeqStack(SeqStack s, ElemType x) {if (s->top >= 0) {x = s->data[s->top];s->top--;}}bool isEmptySeqStack(SeqStack s) {return s->top == -1;}ElemType getTopSeqStack(SeqStack s) {if (s->top >= 0) {return s->data[s->top];}return 0;}// 链栈的基本操作void pushLinkStack(LinkStack s, ElemType x) {LinkStack p = (LinkStack )malloc(sizeof(LinkStack)); if (p == NULL) {exit(1);}p->data = x;p->next = s->top;s->top = p;}void popLinkStack(LinkStack s, ElemType x) { if (s->top != NULL) {LinkStack p = s->top;x = p->data;s->top = p->next;free(p);}}bool isEmptyLinkStack(LinkStack s) {return s->top == NULL;}ElemType getTopLinkStack(LinkStack s) {if (s->top != NULL) {return s->top->data;}return 0;}```2. 判断字符序列是否为回文的函数实现如下:```cbool isPalindrome(char str) {SeqStack s;initStack(&s);int len = strlen(str);for (int i = 0; i < len; i++) {pushSeqStack(&s, str[i]);}for (int i = 0; i < len; i++) {char c = getTopSeqStack(&s);popSeqStack(&s, &c);if (c != str[i]) {return false;}}return true;}```3. 求解整数序列中最大值的函数实现如下:```cint getMax(int arr, int len) {LinkStack s;initStack(&s);int max = arr[0];for (int i = 0; i < len; i++) {pushLinkStack(&s, arr[i]);if (arr[i] > max) {max = arr[i];}}while (!isEmptyLinkStack(&s)) {popLinkStack(&s, &max);}return max;}```五、实验心得通过本次实验,我对栈的基本操作有了更深入的理解。
实验报告一--链接栈与顺序队列的基本运算
课程实验报告题目链接栈与顺序队列的基本运算班级2010信息与计算科学班姓名笑嘻嘻小学号笑嘻嘻完成日期笑嘻嘻小㈠实验要求:编程实现链接栈与顺序队列的基本运算。
链接栈:插入元素,删除栈顶元素,读出栈顶元素,判断栈是否为空。
顺序队列:队列的插入,队列的删除,读队头元素,判断队列是否为空。
实验目的:熟练掌握链接栈,顺序队列的基本运算。
链接栈的结点结构与单链表的结点结构完全相同,即,将链接栈组织成单链表形式。
注意,链接栈中指针的方向是从栈顶指向栈底。
顺序队列是用顺序存储方法存储的队列。
分配一片连续的存储空间,存放队列中的表目,并用两个变量分别指向队头和队尾。
㈡I.链接栈的基本运算I.1实验代码:#include<stdio.h>#include<malloc.h>#define LEN sizeof(struct node)#define NULL 0struct node{int info;struct node*link;};struct linklist{struct node*T;};//*主函数*//void main(){int x;struct linklist L;L.T=(struct node*)malloc(LEN);L.T=NULL;struct linklist push(struct linklist L,int x);struct linklist pop(struct linklist L);int top(struct linklist L);int sempty(struct linklist L); /*函数声明*/for(x=10;x<=50;x=x+10)L=push(L,x); /*向栈顶插入五个元素10,20,30,40,50*/ printf("向栈顶插入五个元素后,");printf("栈顶元素为%d。
顺序栈实验报告
顺序栈实验报告顺序栈实验报告一、引言顺序栈是一种基本的数据结构,它具有先进先出的特点。
在本次实验中,我们将学习并实现顺序栈的基本操作,包括入栈、出栈、判空和获取栈顶元素等。
通过这次实验,我们将深入理解栈的概念和原理,并掌握如何使用顺序栈解决实际问题。
二、实验目的1. 学习顺序栈的定义和基本操作。
2. 掌握顺序栈的实现方法。
3. 理解顺序栈的应用场景。
三、实验过程1. 定义顺序栈的结构在本次实验中,我们选择使用数组来实现顺序栈。
首先,我们需要定义一个栈的结构体,包括栈的容量和栈顶指针。
2. 初始化栈在实验开始时,我们需要初始化一个空栈。
这里,我们将栈顶指针设置为-1,表示栈为空。
3. 入栈操作当我们需要将一个元素压入栈时,我们首先判断栈是否已满。
如果栈已满,则无法进行入栈操作;否则,我们将栈顶指针加1,并将元素放入栈顶位置。
4. 出栈操作当我们需要从栈中弹出一个元素时,我们首先判断栈是否为空。
如果栈为空,则无法进行出栈操作;否则,我们将栈顶指针减1,并返回栈顶元素。
5. 判空操作判断栈是否为空可以通过检查栈顶指针是否等于-1来实现。
如果栈顶指针等于-1,则表示栈为空;否则,表示栈非空。
6. 获取栈顶元素要获取栈顶元素,我们只需返回栈顶指针所指向的元素即可。
需要注意的是,此操作不会改变栈的状态。
四、实验结果通过实验,我们成功实现了顺序栈的基本操作,并进行了测试。
在测试过程中,我们发现顺序栈可以有效地存储和操作数据。
我们可以轻松地将元素入栈和出栈,并通过判断栈是否为空来避免错误操作。
同时,获取栈顶元素的操作也非常方便,可以快速获取栈中最新的数据。
五、实验总结通过本次实验,我们深入了解了顺序栈的概念和原理,并掌握了顺序栈的基本操作。
顺序栈作为一种基本的数据结构,在实际应用中具有广泛的用途。
例如,在计算机程序中,我们可以使用顺序栈来实现函数调用的堆栈,以便保存函数的返回地址和局部变量等信息。
此外,在表达式求值、括号匹配和逆波兰表达式等问题中,顺序栈也发挥着重要的作用。
数据结构栈的实验报告
数据结构栈的实验报告篇一:数据结构栈和队列实验报告一、实验目的和要求(1)理解栈和队列的特征以及它们之间的差异,知道在何时使用那种数据结构。
(2)重点掌握在顺序栈上和链栈上实现栈的基本运算算法,注意栈满和栈空的条件。
(3)重点掌握在顺序队上和链队上实现队列的基本运算算法,注意循环队队列满和队空的条件。
(4)灵活运用栈和队列这两种数据结构解决一些综合应用问题。
二、实验环境和方法实验方法:(一)综合运用课本所学的知识,用不同的算法实现在不同的程序功能。
(二)结合指导老师的指导,解决程序中的问题,正确解决实际中存在的异常情况,逐步改善功能。
(三)根据实验内容,编译程序。
实验环境:Windows xpVisual C++6.0三、实验内容及过程描述实验步骤:①进入Visual C++ 6.0集成环境。
②输入自己编好的程序。
③检查一遍已输入的程序是否有错(包括输入时输错的和编程中的错误),如发现有错,及时改正。
④进行编译和连接。
如果在编译和连接过程中发现错误,频幕上会出现“报错信息”,根据提示找到出错位置和原因,加以改正。
再进行编译,如此反复直到不出错为止。
⑤运行程序并分析运行结果是否合理。
在运行是要注意当输入不同的数据时所得结果是否正确,应运行多次,分别检查在不同情况下结果是否正确。
实验内容:编译以下题目的程序并调试运行。
1)、编写一个程序algo3-1.cpp,实现顺的各种基本运算,并在此基础上设计一程序并完成如下功能:(1)初始化栈s;(2)判断栈s是否非空;序栈个主(3)依次进栈元素a,b,c,d,e;(4)判断栈s是否非空;(5)输出出栈序列;(6)判断栈s是否非空;(7)释放栈。
图3.1 Proj3_1 工程组成本工程Proj3_1的组成结构如图3.1所示。
本工程的模块结构如图3.2所示。
图中方框表示函数,方框中指出函数名,箭头方向表示函数间的调用关系。
图3.2 Proj3_1工程的程序结构图其中包含如下函数:InitStack(SqStack * s) //初始化栈SDestroyStack(SqStack * s) //销毁栈sStackEmpty(SqStack *s) //判断栈空Push(SqStack * s,ElemType e) //进栈Pop(SqStack * s,ElemType e) //出栈GetTop(SqStack *s,ElemType e) //取栈顶元素对应的程序如下://文件名:algo3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;void InitStack(SqStack * s) //初始化栈S { s=(SqStack *)malloc(sizeof(SqStack));s- top=-1; //栈顶指针置为-1}void DestroyStack(SqStack * s) //销毁栈s{free(s);}bool StackEmpty(SqStack *s) //判断栈空{return(s- top==-1);}bool Push(SqStack * s,ElemType e) //进栈{ if (s- top==MaxSize-1) //栈满的情况,即栈上溢出 return false;s- top++; //栈顶指针增1s- data[s- top]=e; //元素e放在栈顶指针处return true;}bool Pop(SqStack * s,ElemType e) //出栈{ if (s- top==-1) //栈为空的情况,即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素s- top--;//栈顶指针减1return true;}bool GetTop(SqStack *s,ElemType e) //取栈顶元素 { if (s- top==-1) //栈为空的情况,即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素return true;}设计exp3-1.cpp程序如下 //文件名:exp3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;extern void InitStack(SqStack *extern void DestroyStack(SqStack *extern bool StackEmpty(SqStack *s);extern bool Push(SqStack * s,ElemType e);extern bool Pop(SqStack * s,ElemTypeextern bool GetTop(SqStack *s,ElemTypevoid main(){ElemType e;SqStack *s;printf( 栈s的基本运算如下:\nprintf( (1)初始化栈s\nInitStack(s);printf( (2)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (3)依次进栈元素a,b,c,d,e\nPush(s, aPush(s, bPush(s, cPush(s, dPush(s, eprintf( (4)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (5)出栈序列:while (!StackEmpty(s)){Pop(s,e);printf( %c ,e);}printf( \nprintf( (6)栈为%s\n ,(StackEmpty(s)? 空 : 非空 ));printf( (7)释放栈\nDestroyStack(s);}运行结果如下:2)、编写一个程序algo3-2.cpp,实现链栈的各种基本运算,并在此基础上设计一个主程序并完成如下功能:(1)初始化链栈s;(2)判断链栈s是否非空;(3)依次进栈a,b,c,d,e;(4)判断链栈s是否非空;(5)输出链栈长度;(6)输出从栈底到栈顶元素;(7)输出出队序列;(8)判断链栈s是否非空;图3.3 Proj3_2工程组成(9)释放队列。
关于栈的实验报告
一、实验目的1. 理解栈的定义、特点、逻辑结构。
2. 掌握顺序栈和链栈的实现方法。
3. 熟悉栈的基本操作,如入栈、出栈、判断栈空等。
4. 掌握栈在解决实际问题中的应用。
二、实验内容1. 实现顺序栈和链栈的基本操作。
2. 利用栈实现一个简单的函数调用栈。
3. 实现一个函数,判断给定的字符串是否为回文。
4. 实现一个函数,将一个整数序列的最大值用递归算法求解。
三、实验过程1. 实现顺序栈和链栈的基本操作(1)顺序栈顺序栈使用数组实现,其操作包括入栈(push)、出栈(pop)、判断栈空(isEmpty)、获取栈顶元素(getTop)等。
(2)链栈链栈使用链表实现,其操作包括入栈(push)、出栈(pop)、判断栈空(isEmpty)、获取栈顶元素(getTop)等。
2. 实现一个简单的函数调用栈使用链栈实现函数调用栈,可以模拟函数的嵌套调用过程。
每当调用一个函数时,就将该函数的参数和局部变量压入栈中;当函数返回时,从栈中弹出参数和局部变量。
3. 实现一个函数,判断给定的字符串是否为回文使用顺序栈或链栈实现,将字符串中的字符依次入栈,然后逐个出栈,判断出栈的字符是否与原字符串相同。
如果相同,则字符串为回文;否则,不是回文。
4. 实现一个函数,将一个整数序列的最大值用递归算法求解使用递归算法,每次递归调用将序列中的最大值与下一个元素比较,将较大的值继续向上传递。
最后,递归函数返回序列中的最大值。
四、实验结果与分析1. 顺序栈和链栈的基本操作实现成功,可以满足实验要求。
2. 函数调用栈实现成功,可以模拟函数的嵌套调用过程。
3. 判断字符串是否为回文的函数实现成功,可以正确判断字符串是否为回文。
4. 求解整数序列最大值的递归算法实现成功,可以正确求解序列中的最大值。
五、实验心得通过本次实验,我对栈数据结构有了更深入的理解。
以下是我对实验的一些心得体会:1. 栈是一种后进先出(LIFO)的数据结构,其特点在于只能在栈顶进行插入和删除操作。
栈的顺序存储实验报告(3篇)
第1篇一、实验目的1. 理解栈的基本概念和顺序存储结构;2. 掌握顺序栈的初始化、进栈、出栈、读栈顶元素等基本操作;3. 通过实际编程实现顺序栈,并验证其功能。
二、实验内容1. 栈的基本概念栈是一种特殊的线性表,它只允许在一端进行插入和删除操作。
栈的插入和删除操作遵循“后进先出”(LIFO)的原则。
2. 顺序栈的定义顺序栈使用数组来存储栈中的元素,数组的大小定义为MaxSize。
栈顶指针top 指向栈顶元素。
3. 顺序栈的基本操作(1)初始化:将栈顶指针top设置为-1,表示栈为空。
(2)进栈:判断栈是否已满,如果未满,则将新元素放入栈顶,并将栈顶指针top加1。
(3)出栈:判断栈是否为空,如果栈不为空,则将栈顶元素弹出,并将栈顶指针top减1。
(4)读栈顶元素:判断栈是否为空,如果栈不为空,则返回栈顶元素。
(5)栈的销毁:释放栈所占用的内存空间。
4. 实验步骤(1)定义栈的最大容量MaxSize;(2)创建顺序栈结构体;(3)实现顺序栈的基本操作函数;(4)编写主函数,测试顺序栈的功能。
1. 定义栈的最大容量MaxSize为100;2. 创建顺序栈结构体,包含数组data和栈顶指针top;3. 实现顺序栈的基本操作函数,包括初始化、进栈、出栈、读栈顶元素和栈的销毁;4. 编写主函数,创建顺序栈,进行进栈、出栈、读栈顶元素等操作,并输出结果。
四、实验结果与分析1. 初始化顺序栈初始化顺序栈后,栈顶指针top为-1,表示栈为空。
2. 进栈操作当向顺序栈中进栈元素时,首先判断栈是否已满。
如果栈未满,则将新元素放入栈顶,并将栈顶指针top加1。
3. 出栈操作当从顺序栈中出栈元素时,首先判断栈是否为空。
如果栈不为空,则将栈顶元素弹出,并将栈顶指针top减1。
4. 读栈顶元素操作当读取栈顶元素时,首先判断栈是否为空。
如果栈不为空,则返回栈顶元素。
5. 栈的销毁当栈不再需要时,释放栈所占用的内存空间。
实验结果表明,顺序栈的基本操作能够正常进行,验证了顺序栈的正确性。
链栈顺序栈实验报告
第五次实验报告——顺序栈、链栈的插入和删除一需求分析1、在演示程序中,出现的元素以数字出现定义为int型,2、演示程序在计算机终端上,用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在终端上3、顺序栈的程序执行的命令包括如下:(1)定义结构体(2)顺序栈的初始化及创建(3)元素的插入(4)元素的删除(5)顺序栈的打印结果3、链栈的程序执行的命令包括如下:(1)定义结构体(2)链栈的初始化及创建(3)元素的插入(4)元素的删除(5)链栈的打印结果二概要设计1、顺序栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n }基本操作:InitStack(SqStack &S)操作结果:构造一个空栈Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;2、链栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n } 基本操作:LinkStack(SqStack &S)操作结果:构造一个空栈Status Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;3、顺序栈程序包含的主要模块:(1) 已给定的函数库:(2)顺序栈结构体:(3)顺序栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:4、链栈程序包含的主要模块:(1) 已给定的函数库:(2)链栈结构体:(3)链栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:三详细设计线性栈:结构体#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{int *base;//在构造栈之前和销毁之后,base的值为NULL int *top;//栈顶指针int stacksize;//当前已分配的存储空间,以元素为单位}SqStack#include"Base.h"主函数#include"construction.h"#include"stack_operation.c"int main(){SqStack S;int choice,e;S=InitStack();S=Input_Sq(S);printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行入栈操作后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法");}}线性栈的创建SqStack InitStack()//线性栈的创建{SqStack S;S.base=(int*)malloc(STACK_INIT_SIZE * sizeof(int));//分配存储空间if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return S;}输入函数SqStack Input_Sq(SqStack S)//输入函数{int n,i;printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个元素",n);for(i=0;i<n;i++){scanf("%d",S.top);S.top++;}return S;}进栈函数SqStack Push(SqStack S,int e)//进栈函数{if(S.top-S.base>=S.stacksize)//判断栈是否为满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;//插入元素return S;}出栈函数SqStack Pop(SqStack S)//删除函数{int e;if(S.top==S.base)printf("线性栈为空");e=*--S.top;return S;}输出函数void Print_Stack(SqStack S)//打印函数{int i;while(S.base!=S.top){for(i=0;i<S.top-S.base;i++){S.top--;printf("%5d",*S.top);}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */ #include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl链栈程序:结构体typedef struct SNode//建立链表结构体{int data;struct SNode *next;}SNode,*LinkStack;主函数#include"Base.h"#include"construction.h"#include"LinkStack_operation.c"int main(){LinkStack S;int choice,e;S=Creatlist_Stack();printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行操作入栈后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法\n");}}创建链栈函数LinkStack Creatlist_Stack()//创建一个链栈{LinkStack S;LinkStack P;int i,n;S=(LinkStack)malloc(sizeof(SNode));S->next=NULL;/* 先建立一个链栈 */printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个数据\n",n);i=0;scanf("%d",&S->data);for(i=1;i<n;++i){P=(LinkStack)malloc(sizeof(SNode)); /* 生成新结点 */P->next=S;S=P;scanf("%d",&S->data); /* 输入元素值 */}return S;}入栈函数LinkStack Push(LinkStack S,int e){LinkStack P;if(S==NULL)return ERROR;P=(LinkStack)malloc(sizeof(SNode));P->data=e;P->next=S;S=P;return S;}出栈函数LinkStack Pop(LinkStack S){LinkStack P,Q;P=S;S=S->next;free(P);return S;}输出函数void Print_Stack(LinkStack S){while(S){printf("%5d",S->data);S=S->next;}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl四调试分析:输出函数用了语句S->next!=NULL改正:语句S!=NULL五用户手册:看提示内容六测试结果线性栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1链栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1。
栈的算法实验报告
一、实验目的1. 理解栈的基本概念和特点,掌握栈的抽象数据类型。
2. 掌握顺序栈和链栈的存储结构及其基本运算实现。
3. 熟练运用栈解决实际问题,如判断字符序列是否为回文、栈内容逆序等。
4. 了解递归算法中栈的状态变化,初步掌握递归的应用。
二、实验内容1. 实现一个判断字符序列是否为回文的算法。
2. 设计一个利用栈操作进行栈内容逆序的算法。
3. 实现一个求解整数数组最大值的递归算法。
三、实验过程1. 判断字符序列是否为回文(1)算法思想:使用栈结构存储字符序列,从序列两端分别遍历,将左端字符压入栈中,将右端字符与栈顶元素进行比较,若相等,则移动指针,继续比较;若不相等,则序列不是回文。
(2)代码实现:```c#include <stdio.h>#include <stdbool.h>#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int top;} Stack;bool initStack(Stack s) {s->top = -1;return true;}bool isEmpty(Stack s) {return s->top == -1;}bool push(Stack s, char x) {if (s->top >= MAX_SIZE - 1) {return false;}s->data[++s->top] = x;return true;}char pop(Stack s) {if (s->top == -1) {return '\0';}return s->data[s->top--];}bool isPalindrome(char str) {Stack s;initStack(&s);for (int i = 0; str[i] != '\0'; i++) {push(&s, str[i]);}while (!isEmpty(&s)) {if (str[i] != pop(&s)) {return false;}i--;}return true;}int main() {char str[] = "abba";if (isPalindrome(str)) {printf("The string is a palindrome.\n");} else {printf("The string is not a palindrome.\n");}return 0;}```2. 利用栈操作进行栈内容逆序(1)算法思想:使用一个临时栈,将原栈中的元素依次弹出,并压入临时栈中,最后将临时栈中的元素依次压回原栈,实现栈内容逆序。
数据结构栈实验报告
一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型,熟练运用顺序栈和链栈进行基本操作,理解递归算法中栈的状态变化,并学会在计算机科学中应用栈解决实际问题。
二、实验内容1. 实现顺序栈和链栈的结构类型定义、特点以及基本操作的实现。
2. 编写算法判断给定字符序列是否为回文。
3. 设计算法,利用栈操作将指定栈中的内容进行逆转。
4. 实现求解整数数组最大值的递归算法。
5. 分析实验过程中遇到的问题及解决方法。
三、实验步骤1. 实现顺序栈和链栈(1)顺序栈顺序栈使用数组实现,具有以下特点:- 存储空间固定,栈的大小预先定义。
- 栈顶指针指示栈顶元素的位置。
- 入栈和出栈操作都在栈顶进行。
- 当栈满时,无法继续入栈。
- 当栈空时,无法继续出栈。
(2)链栈链栈使用链表实现,具有以下特点:- 栈的大小可变,不受存储空间限制。
- 栈顶指针指向栈顶元素的前一个节点。
- 入栈和出栈操作的时间复杂度为O(1)。
- 不存在栈满或栈空的情况。
2. 编写算法判断字符序列是否为回文(1)创建一个空栈。
(2)遍历字符序列,将每个字符依次入栈。
(3)遍历字符序列,将每个字符依次出栈,并判断出栈的字符是否与原序列中的字符相同。
(4)若所有字符均相同,则字符序列为回文;否则,不是回文。
3. 设计算法,利用栈操作将指定栈中的内容进行逆转(1)创建一个空栈。
(2)遍历原栈,将每个元素依次出栈,并判断栈是否为空。
(3)若栈不为空,则将出栈的元素依次入栈。
(4)当原栈为空时,将新栈中的元素依次出栈,实现栈内容的逆转。
4. 实现求解整数数组最大值的递归算法(1)定义一个递归函数,用于求解数组中最大值。
(2)在递归函数中,比较当前元素与左右子数组中的最大值。
(3)返回最大值。
5. 分析实验过程中遇到的问题及解决方法(1)问题:顺序栈在栈满时无法继续入栈。
解决方法:在入栈操作前,判断栈的大小是否已满。
若已满,则提示用户栈已满,无法继续入栈。
教育教学 链栈顺序栈实验报告
链栈顺序栈实验报告1.实验目的本实验旨在通过对链栈和顺序栈两种数据结构的理解和实践操作,加深对栈的性质及其操作的理解,并比较两种栈的优缺点。
通过实际编程,培养解决实际问题的能力,同时体验数据结构在实际应用中的重要性。
2.实验原理链栈是一种用链表实现的栈,其中每个节点都包含一个数据域和两个指针,一个指向下一个节点,另一个指向上一个节点。
顺序栈则是一种用数组实现的栈,具有固定的容量。
两种栈都遵循后进先出(1IFO)的原则。
3.实验步骤(1)定义链栈和顺序栈的结构和操作方法。
(2)创建链栈和顺序栈的实例。
(3)对两种栈进行入栈、出栈等基本操作。
(4)比较两种栈的执行效率。
(5)分析并记录实验结果。
4.实验结果与分析实验结果显示,在大部分情况下,链栈的执行效率高于顺序栈。
这是因为在顺序栈中,元素的存取需要按照数组的索引进行,而链栈中元素的存取只需通过指针链接,因此链栈的操作更高效。
然而,顺序栈的空间利用率高于链栈,因为顺序栈只需预先分配固定容量的空间,而链栈则需要为每个节点分配额外的空间存储指针。
5.实验结论通过本实验,我们得出以下结论:链栈和顺序栈各有优缺点,应根据具体应用场景选择合适的数据结构。
在处理大量数据且内存空间有限的情况下,应优先考虑链栈;而在处理小规模数据且内存空间充足的情况下,顺序栈可能是一个更好的选择。
6.实验问题与改进在实验过程中,我们发现对于链栈来说,如果节点间的链接出现错误,可能会导致整个链表的错误。
因此,我们需要更加细心地处理链表中的链接问题。
此外,我们还需提高编程技巧和细心程度,避免在实验过程中出现错误。
7.实验体会与展望通过本次实验,我们更加深入地理解了栈的性质及其操作,并掌握了链栈和顺序栈的实现方法。
我们还了解了两种数据结构的优缺点以及在实际应用中的适用场景。
在未来的学习和工作中,我们将继续深入学习数据结构及其相关领域的知识,以提高我们的编程能力和解决问题的能力。
同时,我们也将努力将所学的知识和技能应用于实际问题的解决中,以实现学以致用的目标。
栈实验报告
实验项目名称栈的应用一.实验目的掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。
三.实验内容1.顺序栈的实现和运算2.链栈的实现和运算四、主要仪器设备及耗材VC++6.0运行环境实现其操作五.程序算法1>.顺序栈的实现a.顺序栈的数据类型CONST int maxsize=maxlen; //定义栈的最大容量为maxlenStruct seqstack{elemtype stack[maxsize]; //将栈中元素定义为elemtype类型int top; //指向栈顶位置的指针(数组编号)}b.初始化栈void inistack(seqstack &s){s.top=0;}c.进栈void push(seqstack &s, elemtype x){if (s.top==maxsize-1} cout<<”overflow”;else{s.top++;s.stack[s.top]=x;}}d.)退栈void pop(seqstack &s){if (s.top= =0) cout<<”underflow”; elses.top--;}e.)取栈顶元素elemtype gettop(seqstack s){if (s.top= =0){ cout<<”underflow”;return 0;}else return s.stack[s.top];}f.)判栈空否int empty(seqstack s){if (s.top= =0) return 1;else return 0;}2>.链栈的实现a.栈初始化void inistack(link *top){ top->next=NULL;}b.进栈运算void push(link *top,int x){ link *s;s=new link;s->data=x;s->next=top->next; //头插法top->next=s; }c.退栈运算void pop(link *top){link *s;s=top->next;if(s!=NULL){top->next=s->next;delete(s);}}d.取栈顶元素elemtype gettop(link *top){if(top->next!=NULL)return(top->next->data);elsereturn(NULL);}e.判栈空int empty(link *top){if(top->next==NULL)return(1);elsereturn(0);}六.程序源代码1>.顺序栈的实现代码#include<iostream.h>#define max 100struct seqstack{int stack[max];int top;};void init(seqstack &s)/*初始化*/{s.top=0;//return 1;}void push(seqstack &s,int x) /*入栈操作*/ {if (s.top==max)cout<<"the stack is overflow!";else{s.top++;s.stack[s.top]=x;}}void display(seqstack &s) /*显示栈所有数据*/{int t;t=s.top;if(t==0)cout<<"the stack is empty!";else{ cout<<"从栈顶到栈底输出:"<<endl;while(t!=0){cout<<s.stack[t]<<"->";t--;}}cout<<endl;}void pop(seqstack &s)/*出栈操作并返回被删除的那个记录*/ {if(s.top==0)cout<<"the stack is empty!";elses.top--;}int gettop(seqstack s) /*得到栈顶数*/{if(s.top==0)return 0;elsereturn s.stack[s.top];}int IsEmpty(seqstack s) {if(s.top == 0) return 1;return 0;}main(){seqstack p;int i,x,y;init(p);cout<<"输入元素到0时为止"<<endl;cin>>i;while(i){push(p,i);cin>>i;}pop(p);x=gettop(p);cout<<"x="<<x<<endl;display(p);while(p.top!=0)pop(p);y=IsEmpty(p);if(y==1)cout<<"空栈";elsecout<<"非空栈";cout<<endl;}2>.链栈的实现代码#include <iostream.h>typedef struct QNode{char data;QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;InitQueue(LinkQueue &Q){Q.front=Q.rear=new QNode;Q.front->next=NULL;return 0;}EnQueue(LinkQueue &Q,char e){QueuePtr p;p=new QNode;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return 0;}void disp(LinkQueue &Q) //打印队列{QueuePtr p;p=Q.front->next;while(p!=NULL){cout<<p->data<<"->";p=p->next;}}DeQueue(LinkQueue &Q,char &e){QueuePtr p;if(Q.front==Q.rear)return 1;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;delete p;return 0;}void main(){LinkQueue Q;char e,e1;InitQueue(Q);cout<<"输入队列元素,0时结束:"<<endl;cin>>e;while(e!='0'){EnQueue(Q,e);cin>>e;}cout<<"队列为:"<<endl;disp(Q);DeQueue(Q,e1);cout<<endl<<"执行一次删除队头,删除的元素是:"<<e1<<endl;cout<<"队列为:"<<endl;disp(Q);cout<<endl;}七.实验数据及实验结果1>.顺序栈的实验结果2>.链栈的实验结果八、思考讨论题或体会或对改进实验的建议(1)体会a.C++语言知识不懂,需要好好学习;b.对单链表不够熟悉,要多练习创建单链表及其基本操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第五次实验报告——顺序栈、链栈的插入和删除一需求分析1、在演示程序中,出现的元素以数字出现定义为int型,2、演示程序在计算机终端上,用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在终端上3、顺序栈的程序执行的命令包括如下:(1)定义结构体(2)顺序栈的初始化及创建(3)元素的插入(4)元素的删除(5)顺序栈的打印结果3、链栈的程序执行的命令包括如下:(1)定义结构体(2)链栈的初始化及创建(3)元素的插入(4)元素的删除(5)链栈的打印结果二概要设计1、顺序栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n }基本操作:InitStack(SqStack &S)操作结果:构造一个空栈Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;2、链栈可能需要用到有序表的抽象数据类型定义:ADT List{数据对象:D={ai|ai∈ElemL, i=1,2,...,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai ∈D, i=2,...,n } 基本操作:LinkStack(SqStack &S)操作结果:构造一个空栈Status Push(L,e)操作结果:插入元素e为新的栈顶元素Status Pop(SqStack &S)操作结果:删除栈顶元素}ADT List;3、顺序栈程序包含的主要模块:(1) 已给定的函数库:(2)顺序栈结构体:(3)顺序栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:4、链栈程序包含的主要模块:(1) 已给定的函数库:(2)链栈结构体:(3)链栈初始化及创建:(4)元素插入(5)元素删除(6)主程序:三详细设计线性栈:结构体#define STACK_INIT_SIZE 100//存储空间初始分配量#define STACKINCREMENT 10//存储空间分配增量typedef struct{int *base;//在构造栈之前和销毁之后,base的值为NULL int *top;//栈顶指针int stacksize;//当前已分配的存储空间,以元素为单位}SqStack#include"Base.h"主函数#include"construction.h"#include"stack_operation.c"int main(){SqStack S;int choice,e;S=InitStack();S=Input_Sq(S);printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行入栈操作后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法");}}线性栈的创建SqStack InitStack()//线性栈的创建{SqStack S;S.base=(int*)malloc(STACK_INIT_SIZE * sizeof(int));//分配存储空间if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return S;}输入函数SqStack Input_Sq(SqStack S)//输入函数{int n,i;printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个元素",n);for(i=0;i<n;i++){scanf("%d",S.top);S.top++;}return S;}进栈函数SqStack Push(SqStack S,int e)//进栈函数{if(S.top-S.base>=S.stacksize)//判断栈是否为满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(int));if(!S.base)exit(OVERFLOW);//存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;//插入元素return S;}出栈函数SqStack Pop(SqStack S)//删除函数{int e;if(S.top==S.base)printf("线性栈为空");e=*--S.top;return S;}输出函数void Print_Stack(SqStack S)//打印函数{int i;while(S.base!=S.top){for(i=0;i<S.top-S.base;i++){S.top--;printf("%5d",*S.top);}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */ #include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl链栈程序:结构体typedef struct SNode//建立链表结构体{int data;struct SNode *next;}SNode,*LinkStack;主函数#include"Base.h"#include"construction.h"#include"LinkStack_operation.c"int main(){LinkStack S;int choice,e;S=Creatlist_Stack();printf("请选择执行的操作,输入1执行入栈操作,输入2执行出栈操作choice=");scanf("%d",&choice);switch(choice){case 1:{printf("请输入插入元素的值e=");scanf("%d",&e);S=Push(S,e);printf("执行操作入栈后的线性栈为");Print_Stack(S);};break;case 2:{S=Pop(S);printf("执行出栈操作后的线性栈为");Print_Stack(S);};break;default : printf("您输入的值不合法\n");}}创建链栈函数LinkStack Creatlist_Stack()//创建一个链栈{LinkStack S;LinkStack P;int i,n;S=(LinkStack)malloc(sizeof(SNode));S->next=NULL;/* 先建立一个链栈 */printf("请输入元素个数n=");scanf("%d",&n);printf("请输入%d个数据\n",n);i=0;scanf("%d",&S->data);for(i=1;i<n;++i){P=(LinkStack)malloc(sizeof(SNode)); /* 生成新结点 */P->next=S;S=P;scanf("%d",&S->data); /* 输入元素值 */}return S;}入栈函数LinkStack Push(LinkStack S,int e){LinkStack P;if(S==NULL)return ERROR;P=(LinkStack)malloc(sizeof(SNode));P->data=e;P->next=S;S=P;return S;}出栈函数LinkStack Pop(LinkStack S){LinkStack P,Q;P=S;S=S->next;free(P);return S;}输出函数void Print_Stack(LinkStack S){while(S){printf("%5d",S->data);S=S->next;}printf("\n");}库函数* Base.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSEl四调试分析:输出函数用了语句S->next!=NULL改正:语句S!=NULL五用户手册:看提示内容六测试结果线性栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1链栈:1)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=1,请输入插入元素的值e=6,执行入栈操作后的线性栈为6 4 3 2 1 2)请输入元素的个数:4,请输入4个数据 1 2 3 4,请输入执行语句,选择输入1执行入栈操作,选择输入2执行出栈操作choice=2,执行出栈操作后的线性栈为3 2 1。