实验四、栈的顺序和链式存储的表示和实现

合集下载

栈的实验报告结论(3篇)

栈的实验报告结论(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)测试程序:验证了栈在程序设计中的应用。

线性结构-栈的顺序存储和链式存储实现

线性结构-栈的顺序存储和链式存储实现

线性结构-栈的顺序存储和链式存储实现栈的顺序存储表⽰栈的顺序存储结构简称为顺序栈,和线性表相类似,⽤⼀维数组来存储栈。

根据数组是否可以根据需要增⼤,⼜可分为静态顺序栈和动态顺序栈。

静态顺序栈实现简单,但不能根据需要增⼤栈的存储空间;动态顺序栈可以根据需要增⼤栈的存储空间,但实现稍为复杂。

栈的动态顺序存储表⽰采⽤动态⼀维数组来存储栈。

所谓动态,指的是栈的⼤⼩可以根据需要增加。

⽤bottom表⽰栈底指针,栈底固定不变的;栈顶则随着进栈和退栈操作⽽变化。

⽤top(称为栈顶指针)指⽰当前栈顶位置。

⽤top=bottom作为栈空的标记,每次top指向栈顶数组中的下⼀个存储位置。

结点进栈:⾸先将数据元素保存到栈顶(top所指的当前位置),然后执⾏top加1,使top指向栈顶的下⼀个存储位置;结点出栈:⾸先执⾏top减1,使top指向栈顶元素的存储位置,然后将栈顶元素取出。

栈的静态顺序存储表⽰采⽤静态⼀维数组来存储栈。

栈底固定不变的;栈顶则随着进栈和退栈操作⽽变化,⽤⼀个整型变量top(称为栈顶指针)来指⽰当前栈顶位置。

⽤top=0表⽰栈空的初始状态,每次top指向栈顶在数组中的存储位置。

结点进栈:⾸先执⾏top加1,使top指向新的栈顶位置,然后将数据元素保存到栈顶(top所指的当前位置)。

结点出栈:⾸先把top指向的栈顶元素取出,然后执⾏top减1,使top指向新的栈顶位置。

若栈的数组有Maxsize个元素,则top=Maxsize-1时栈满。

/*!* \file 栈的顺序存储实现.cpp** \author ranjiewen* \date 2017/03/17 11:13***/#include <stdio.h>#include <stdlib.h>typedef int Position;typedef int ElemType;#define ERROR NULL#define MAXSIVE 100struct SNode{ElemType *Data; /*存储元素的数组,动态分配内存*/Position Top; /*栈顶元素数组下标*/int MaxSize; // 堆栈最⼤容量};typedef struct SNode* Stack;Stack CreateStack(int MaxSize){Stack S = (Stack)malloc(sizeof(struct SNode));S->Data = (ElemType*)malloc(MaxSize*sizeof(ElemType));S->Top = -1; //顺序存储结构时,表⽰空S->MaxSize = MaxSize;return S;}bool IsFull(Stack S){return (S->Top == S->MaxSize - 1);}bool Push(Stack S, ElemType x){if (IsFull(S)){printf("堆栈满.\n"); //栈满时可以再申请空间return false;}else{S->Data[++(S->Top)] = x;return true;}}bool IsEmpty(Stack S){return (S->Top == -1);}ElemType Pop(Stack S){if (IsEmpty(S)){printf("堆栈为空。

栈-队列的顺序-链式储存结构(数据结构试验报告)

栈-队列的顺序-链式储存结构(数据结构试验报告)

数据结构实验报告班级:计学号:姓名:设计日期:西安计算机学院实验题目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. 编写递归程序,实现N !的求解。

3. 编写递归程序,实现以下函数的求解。

4. 编写程序,实现Hanoi 塔问题。

【实验步骤】1.打开VC++。

2.建立工程:点File->New ,选Project 标签,在列表中选Win32 Console Application ,再在右边的框里为工程起好名字,选好路径,点OK->finish 。

至此工程建立完毕。

3.创建源文件或头文件:点File->New ,选File 标签,在列表里选C++ Source File 。

给文件起好名字,选好路径,点OK 。

至此一个源文件就被添加到了你刚创建的工程之中。

4.写好代码5.编译->链接->调试1、#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define OK 1⎩⎨⎧>-+-==1),2()1(0,1,)(n n Fib n Fib n n n Fib#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int SElemType;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack(SqStack &S){S.base=(SElemType *)malloc (STACK_INIT_SIZE*sizeof(SElemType));if (!S.base) return OVERFLOW;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}//InitStackStatus Push(SqStack &S, SElemType e){if (S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;} //PUSHStatus Pop(SqStack &S, SElemType &e) {if(S.top==S.base)return ERROR;e=*--S.top;return OK;} //PopStatus StackEmpty(SqStack S){if (S.top==S.base)return OK;elsereturn ERROR;} //StackEmptyvoid conversion(){int N;int e;SqStack S;InitStack(S);printf("输入要转换的数据:");scanf("%d",&N);while (N){Push(S, N % 8);N = N/8;}printf("\n其对应的八进制数是:");while (!StackEmpty(S)){Pop(S,e);printf ( "%d", e );}}void main(){conversion();}2、#include <stdio.h>Int fact(int n){If(n==1)return 1;elsereturn n*fact(n-1);}void main(){Int n;printf(“输入一个数n:”);scanf(“%d”,&n);printf("fact(%d)=%d\n",n,fact(n)); }3、#include <stdio.h>int fib(int n){if(n>1)return fib(n-1)+fib(n-2);elsereturn n;}void main(){int n;printf("\n输入一个数n:");scanf("%d",&n);printf("fib(%d)=%d\n",n,fib(n));}4、#include <stdio.h>void move(char x,int n,char z){printf("将%d号盘从%c柱移到%c柱\n",n,x,z);}void hanoi (int n, char x, char y, char z) { if (n==1)move(x,1,z);else{hanoi(n-1, x, z, y);move(x, n, z);hanoi(n-1, y, x, z);}}void main(){int n;scanf("%d",&n);hanoi(n,'x','y','z');}【实验心得】这节课的实验内容是栈的表示与实现及栈的应用。

栈及其应用实验报告

栈及其应用实验报告

一、实验目的1. 理解栈的定义、特点、逻辑结构及其在计算机科学中的应用。

2. 掌握顺序栈和链栈的存储结构及基本操作实现。

3. 通过具体应用实例,加深对栈的理解,提高问题分析和解决的能力。

二、实验内容1. 实现顺序栈和链栈的基本操作。

2. 编写一个算法,判断给定的字符序列是否为回文。

3. 编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。

4. 给定一个整数序列,实现一个求解其中最大值的递归算法。

三、实验步骤1. 实现顺序栈和链栈的基本操作(1)顺序栈的存储结构及操作实现顺序栈使用数组来实现,其基本操作包括:- 初始化栈:使用数组创建一个空栈,并设置栈的最大容量。

- 入栈:将元素插入栈顶,如果栈满,则返回错误。

- 出栈:从栈顶删除元素,如果栈空,则返回错误。

- 获取栈顶元素:返回栈顶元素,但不删除。

- 判断栈空:判断栈是否为空。

(2)链栈的存储结构及操作实现链栈使用链表来实现,其基本操作包括:- 初始化栈:创建一个空链表,作为栈的存储结构。

- 入栈:在链表头部插入元素,如果链表为空,则创建第一个节点。

- 出栈:删除链表头部节点,如果链表为空,则返回错误。

- 获取栈顶元素:返回链表头部节点的数据。

- 判断栈空:判断链表是否为空。

2. 判断字符序列是否为回文编写一个算法,判断给定的字符序列是否为回文。

算法步骤如下:(1)使用顺序栈或链栈存储字符序列。

(2)从字符序列的头部开始,依次将字符入栈。

(3)从字符序列的尾部开始,依次将字符出栈,并与栈顶元素比较。

(4)如果所有字符均与栈顶元素相等,则字符序列为回文。

3. 利用栈的基本运算将指定栈中的内容进行逆转编写一个算法,利用栈的基本运算将指定栈中的内容进行逆转。

算法步骤如下:(1)创建一个空栈,用于存储逆转后的栈内容。

(2)从原栈中依次将元素出栈,并依次入新栈。

(3)将新栈的内容赋值回原栈,实现栈内容的逆转。

4. 求解整数序列中的最大值给定一个整数序列,实现一个求解其中最大值的递归算法。

栈的存取实验报告

栈的存取实验报告

一、实验目的1. 理解栈的基本概念和特性;2. 掌握栈的顺序存储和链式存储结构;3. 熟练掌握栈的基本操作,如入栈、出栈、初始化等;4. 通过实际操作,加深对栈在实际问题中的应用理解。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 栈的顺序存储结构实现2. 栈的链式存储结构实现3. 栈的基本操作实现4. 栈的实际应用案例分析四、实验步骤1. 栈的顺序存储结构实现(1)定义栈的顺序存储结构体(2)实现栈的初始化、入栈、出栈等基本操作2. 栈的链式存储结构实现(1)定义栈的链式存储结构体(2)实现栈的初始化、入栈、出栈等基本操作3. 栈的基本操作实现(1)编写函数实现栈的初始化(2)编写函数实现栈的入栈操作(3)编写函数实现栈的出栈操作(4)编写函数实现获取栈顶元素4. 栈的实际应用案例分析(1)模拟火车进站和出站过程(2)计算表达式求值(3)实现函数调用栈五、实验结果与分析1. 栈的顺序存储结构实现(1)成功实现了栈的顺序存储结构体(2)成功实现了栈的初始化、入栈、出栈等基本操作2. 栈的链式存储结构实现(1)成功实现了栈的链式存储结构体(2)成功实现了栈的初始化、入栈、出栈等基本操作3. 栈的基本操作实现(1)成功实现了栈的初始化函数(2)成功实现了栈的入栈函数(3)成功实现了栈的出栈函数(4)成功实现了获取栈顶元素函数4. 栈的实际应用案例分析(1)成功模拟了火车进站和出站过程(2)成功实现了表达式求值(3)成功实现了函数调用栈六、实验心得通过本次实验,我对栈的存储结构、基本操作以及实际应用有了更深入的理解。

以下是我对本次实验的几点心得体会:1. 栈是一种后进先出(LIFO)的数据结构,在解决实际问题中具有重要的应用价值;2. 栈的顺序存储和链式存储结构各有优缺点,选择合适的存储结构可以更好地满足实际需求;3. 栈的基本操作相对简单,但需要注意栈满和栈空的情况;4. 栈在实际应用中具有广泛的应用场景,如函数调用栈、表达式求值等。

堆栈的实验报告

堆栈的实验报告

一、实验目的1. 理解堆栈的基本概念和原理;2. 掌握堆栈的顺序存储和链式存储方法;3. 熟悉堆栈的基本操作,如入栈、出栈、判断栈空、求栈顶元素等;4. 能够运用堆栈解决实际问题。

二、实验内容1. 堆栈的基本概念和原理;2. 堆栈的顺序存储和链式存储方法;3. 堆栈的基本操作实现;4. 堆栈的应用实例。

三、实验原理1. 堆栈的基本概念和原理:堆栈是一种特殊的线性表,它按照“后进先出”(LIFO)的原则组织数据。

即最后进入堆栈的数据元素最先出栈。

2. 堆栈的顺序存储方法:使用一维数组实现堆栈,栈顶指针top指向栈顶元素。

3. 堆栈的链式存储方法:使用链表实现堆栈,每个节点包含数据域和指针域。

4. 堆栈的基本操作实现:(1)入栈:将元素插入到栈顶,如果栈未满,则top指针加1,并将元素值赋给top指向的元素。

(2)出栈:删除栈顶元素,如果栈不为空,则将top指向的元素值赋给变量,并将top指针减1。

(3)判断栈空:如果top指针为-1,则表示栈为空。

(4)求栈顶元素:如果栈不为空,则将top指向的元素值赋给变量。

四、实验步骤1. 使用顺序存储方法实现堆栈的基本操作;2. 使用链式存储方法实现堆栈的基本操作;3. 编写程序,测试堆栈的基本操作是否正确;4. 分析实验结果,总结实验经验。

五、实验结果与分析1. 使用顺序存储方法实现堆栈的基本操作:(1)入栈操作:当栈未满时,将元素插入到栈顶。

(2)出栈操作:当栈不为空时,删除栈顶元素。

(3)判断栈空:当top指针为-1时,表示栈为空。

(4)求栈顶元素:当栈不为空时,返回top指向的元素值。

2. 使用链式存储方法实现堆栈的基本操作:(1)入栈操作:创建新节点,将其作为栈顶元素,并修改top指针。

(2)出栈操作:删除栈顶元素,并修改top指针。

(3)判断栈空:当top指针为NULL时,表示栈为空。

(4)求栈顶元素:返回top指针指向的节点数据。

3. 实验结果分析:通过实验,验证了顺序存储和链式存储方法实现的堆栈基本操作的正确性。

河南师范大学栈的顺序存储结构实现实验报告

河南师范大学栈的顺序存储结构实现实验报告
(2)熟练掌握了栈的基本操作实现方法;
(3)能在相应的应用问题中正确选用抽象数据类型;
实验指导教师
杨育捷
实验成绩
(3)根据其结构特性进行设计编写;
实验设计:
(1 )根据实验要求,先建立一个空栈;
(2)设计算法整体的框架,在逐步细化;
(3)设计简便的算法进行实验;
(4)编写源代码,并进行编译与纠错;
(5)输出结果;
设计程序如下:
编译如下:
输出结果:
分析与体会:
(1)通过此次试验,了解了栈的顺序存储的特点,进一步加深了对栈的理解;
实验目的:
(1)了解栈和队列的结构特性;
(2)掌握在两种存储结构上实现栈和队列的基本操作;
(3)掌握栈和队列这两种抽象数据的特点;
(4)熟练掌握栈类型的两种实现方法即基本操作实现算法;
实验分析:
(1)栈的顺序存储结构就是利用一组地址连续的存储单元依次放入栈中;
(2)设定头指针指示栈顶元素在顺序栈中的位置;
河南师范大学栈的顺序存储结构实现实验报告栈的顺序存储结构河南师范大学河南师范大学新联学院河南师范大学研究生院河南师范大学首页河南师范大学附属中学河南师范大学图书馆河南师范大学学报河南师范大学教务处
栈的顺序存储结构实现实验报告
2014年月日
学号
姓名
时间
专业计算Βιβλιοθήκη 科学与技术软件设计班级实验题目:栈的顺序存储结构实现实验报告

栈的顺序表示和实现

栈的顺序表示和实现

一.实验目的和要求1、掌握栈的存储结构及其基本操作。

学会定义栈的顺序存储结构及其各种基本操作的实现。

2、掌握栈的后进先出原则。

3、通过具体的应用实例,进一步熟悉和掌握栈在实际问题中的运用。

二.实验内容1、设栈采用顺序存储结构(用动态数组),请编写栈的各种基本操作的实现函数,并存放在头文件stack.h中。

同时建立一个验证操作实现的主函数文件stack.cpp,编译并调试程序,直到正确运行。

提示:⑴栈的动态数组顺序存储结构可定义如下:int IsReverse(char struct Stack {ElemType *stack ; // 存栈元素int top; // 栈顶指示器int MaxSize; // 栈的最大长度};⑵栈的基本操作可包括:①void InitStack (Stack &S); //构造一个空栈S②int EmptyStack (Stack S); //若栈S为空栈返回1,否则返回0③void Push(Stack &S, ElemType item); //元素item进栈④ElemType Pop(Stack &S); //栈S的栈顶元素出栈并返回⑤ElemType Peek(Stack S); //取栈S的当前栈顶元素并返回⑥void ClearStack (Stack &S); //清除栈s,使成为空栈2、应用:写一函数,判断给定的字符串是否中心对称。

如字符串“abcba”、“abccba”均为中心对称,字符串“abcdba”不中心对称。

要求利用test7.h中已实现的有关栈的基本操作函数来实现。

请把该函数添加到文件test7.cpp中的主函数前,并在主函数中添加相应语句进行测试。

函数原型如下:*s) //判断字符串S是否中心对称,是返回1,否则返回03、填写实验报告,实验报告文件取名为report7.doc。

4、上传实验报告文件report7.doc 、源程序文件test7.cpp及test7.h到Ftp服务器上(ftp://10.61.14.240:5000 )自己的文件夹下。

栈的表示及栈的应用实验心得

栈的表示及栈的应用实验心得

栈的表示及栈的应用实验心得
栈是一种常见的数据结构,特点是后进先出,常用于程序内存中的函数调用、表达式
求值等方面。

栈有多种表示方法,常见的包括顺序栈和链式栈。

在顺序栈中,使用一
个数组来表示栈,通过一个指针指向栈顶元素,实现栈的基本操作。

链式栈是在链表
的基础上实现栈,其中栈顶元素表示为链表的头结点。

在实验中,我通过编写程序来熟悉了使用栈。

具体来说,我设计了一个括号匹配程序。

该程序可以读取一个字符串,检查其中的括号是否匹配,如果匹配则输出“括号匹配”,否则输出“括号不匹配”。

在程序中,我使用顺序栈来实现检查括号匹配的功能。

具体来说,我遍历每一个字符,遇到左括号时则将其压入栈中,遇到右括号时则
判断栈顶元素是否为相应的左括号,如果匹配则弹出栈顶元素,继续遍历字符串,直
至遍历完成。

如果遍历完成后栈为空,则表示字符串中的括号匹配,否则表示不匹配。

通过这个实验,我对栈的表示和使用有了更深入的了解。

共享一下这个实验心得,希
望对其他学习数据结构的同学有所帮助。

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈,出栈操作;2、掌握队列的结构特性及其⼊队、出队的操作,掌握循环队列的特点及其操作。

⼆、实验预习说明以下概念1、顺序栈:2、链栈:3、循环队列:4、链队三、实验内容和要求1、阅读下⾯程序,将函数Push和函数Pop补充完整。

要求输⼊元素序列1 2 3 4 5 e,运⾏结果如下所⽰。

#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析:输⼊元素序列1 2 3 4 5,为什么输出序列为5 4 3 2 1?体现了栈的什么特性?2、在第1题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。

堆栈链式存储结构表示与实现实验报告.doc

堆栈链式存储结构表示与实现实验报告.doc

堆栈链式存储结构表示与实现实验报告根据统计和数据,该报告形成并报告班级级别:学校编号:姓氏:Word数据实验主题:堆栈链式存储结构的表达和实验的实现日期;实验要求:1.仔细阅读并掌握本实验的相关知识。

2.编写程序实现栈的链式存储模式。

3.编写程序实现栈空判断、栈入栈出操作和栈顶元素提取。

4.保存程序的运行结果,结合程序分析链结构的特点。

5.填写实验报告的概要设计:(1)初始化链栈。

(2)清空链栈。

(3)完成堆栈入口和堆栈出口操作,并完成堆栈顶部元素提取操作。

(4)选择菜单上的0退出程序并结束实验。

初始化堆栈操作,并将堆栈的顶部指针设置为空值,即设置堆栈S和顶部指针顶部,S→顶部=空。

如果在构建的堆栈中有数据元素,还需要将堆栈顶部指针的值设置为空。

将数据元素插入堆栈的堆栈操作。

首先,应将节点分配给插入的数据元素,并将插入的数据元素的值分配给插入节点的数据字段。

其次,应该修改栈顶指针的指向关系,即应该修改插入节点和栈顶指针的地址。

最后,应该修改栈顶指针。

推送操作从堆栈中移除数据元素。

首先,必须判断堆栈是否为空,如果为空,操作将失败。

否则,栈被推出,删除节点和栈顶指针被修改,最后删除节点被释放。

以堆栈的顶部元素为例。

详细设计://链堆栈类型定义typedef int ElemTypetypedef结构stacknode{ ElemType数据;堆叠*下一个;} StackNodetypedef结构{ stacknode * top}链接堆栈;//进入堆栈void pushl堆栈(linkstack * s,elem type x){ stack de * p;p=新StackNodeP-学校编号:姓氏:Word数据实验主题:堆栈链式存储结构的表达和实验的实现日期;实验要求:1.仔细阅读并掌握本实验的相关知识。

2.编写程序实现栈的链式存储模式。

3.编写程序实现栈空判断、栈入栈出操作和栈顶元素提取。

4.保存程序的运行结果,结合程序分析链结构的特点。

栈的顺序存储实验报告(3篇)

栈的顺序存储实验报告(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)定义栈的顺序存取结构。

(2)分别定义顺序栈的基本操作(初始化栈、判栈空、入栈、出栈等)。

(3)设计一个测试主函数进行测试。

三.实验要求(1)根据实验内容编写程序,上机调试并获得运行结果(2)撰写实验报告四.准备工作本次实验将会建立下图所示顺序栈,并会根据此顺序栈进行新增,删除等操作五.关键操作思路与算法(1)定义顺序栈利用顺序存储方式实现的栈称为顺序栈。

栈中的数据元素可用一个预设的足够长度的一维数组来实现:datatype data[MAXNUM],栈底位置一般设置在数组的低端处,在整个进栈和出栈的过程中不改变,而栈顶位置将随着数据元素进栈和出栈而变化,为了指明当前栈顶在数组中的位置,一般用top作为栈顶指针,算法如下;1.#define MAXNUM 1002.typedef int datatype;3.4.typedef struct{5. datatype data[MAXNUM];6.int top;7.}SeqStack;(2)置空栈算法思路;(1)向系统申请栈空间(2)初始化栈顶指针top,置空栈标志top=-1算法如下;1.void StackSetNull(SeqStack *s)2.{3. s->top=-1;4.}(3)判断是否为空栈算法如下;1.//判断栈是否为空2.int StackIsEmpty(SeqStack *s)3.{4.if(s->top == -1)5.return TRUE;6.else7.return FALSE;8.}9.}(4)入栈算法思路;(1)判断当前栈空间是否已满,若已满,则返回0,未满则转第(2步)(2)栈顶指针top++(3)将元素赋值到top所指位置作为新的栈顶元素,成功返回值1.算法如下;1.//进栈2.int StackPush(SeqStack *s,datatype x)3.{4.if(s->top==MAXNUM-1)5. {6. printf("栈上溢出!\n");7.return FALSE;8. }9.else10. {11. s->top=s->top+1;12. s->data[s->top]=x;13.return TRUE;14. }15.}(五)出栈算法思路;(1)判断当前栈空间是否为空,若为空,则返回0,不为空则转第(2步)(2)将top指针所指位置元素值取出(3)栈顶指针top--指向新的栈顶元素,成功返回值1.算法如下;1.//出栈2.int StackPop(SeqStack *s,datatype *x)3.{4.if(s->top==-1)5. {6. printf("栈下溢出!\n");7.return FALSE;8. }9.else10. {11. * x=s->data[s->top];12.//s->top=s->top-1;13. s->top --;14.return TRUE;15. }16.}(六)读栈顶元素算法如下;1.//读栈顶2.datatype StackGetTop(SeqStack *s)3.{4.if(s->top==-1)5. {6. printf("栈下溢出!\n");7.return FALSE;8. }9.else10.return (s->data[s->top]);11.}六.注意事项(1)置空栈需要向系统申请空间后再设置空栈标志,而判断空栈则无须申请空间直接判断空栈标志是否成立。

链栈顺序栈实验报告

链栈顺序栈实验报告

第五次实验报告——顺序栈、链栈的插入和删除一需求分析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.通过编写程序实现栈的基本操作和应用。

三、实验内容
1.栈的定义:栈是一种具有特定结构的数据类型,其特殊之处在于只能从固定的一端(称为栈顶)进行插入,删除和查找操作。

2.栈的存储结构:栈既可以采用顺序存储结构,也可以采用链式存储结构。

3.栈的基本操作有:进栈(push)、出栈(pop)、查看栈顶元素(get_top)、清空栈(clear)、获取栈长度(length)等。

4.栈的应用:主要用于表达式求值、括号匹配、逆序输出等操作。

五、实验步骤
2.编写程序实现栈结构的创建、进栈、出栈、查看栈顶元素、清空栈、获取栈长度等基本操作。

四、实验结果
1.按照实验要求,成功创建一个栈的数据结构,并实现栈的基本操作。

栈作为常用的一种数据结构,在实际的编程中有广泛的应用。

通过本次实验的学习,对栈的概念、特点、实现方式有了更深刻的了解,同时也掌握了栈的一些应用操作,这对于提高代码效率和解决实际问题有很大的帮助。

教育教学 链栈顺序栈实验报告

教育教学 链栈顺序栈实验报告

链栈顺序栈实验报告1.实验目的本实验旨在通过对链栈和顺序栈两种数据结构的理解和实践操作,加深对栈的性质及其操作的理解,并比较两种栈的优缺点。

通过实际编程,培养解决实际问题的能力,同时体验数据结构在实际应用中的重要性。

2.实验原理链栈是一种用链表实现的栈,其中每个节点都包含一个数据域和两个指针,一个指向下一个节点,另一个指向上一个节点。

顺序栈则是一种用数组实现的栈,具有固定的容量。

两种栈都遵循后进先出(1IFO)的原则。

3.实验步骤(1)定义链栈和顺序栈的结构和操作方法。

(2)创建链栈和顺序栈的实例。

(3)对两种栈进行入栈、出栈等基本操作。

(4)比较两种栈的执行效率。

(5)分析并记录实验结果。

4.实验结果与分析实验结果显示,在大部分情况下,链栈的执行效率高于顺序栈。

这是因为在顺序栈中,元素的存取需要按照数组的索引进行,而链栈中元素的存取只需通过指针链接,因此链栈的操作更高效。

然而,顺序栈的空间利用率高于链栈,因为顺序栈只需预先分配固定容量的空间,而链栈则需要为每个节点分配额外的空间存储指针。

5.实验结论通过本实验,我们得出以下结论:链栈和顺序栈各有优缺点,应根据具体应用场景选择合适的数据结构。

在处理大量数据且内存空间有限的情况下,应优先考虑链栈;而在处理小规模数据且内存空间充足的情况下,顺序栈可能是一个更好的选择。

6.实验问题与改进在实验过程中,我们发现对于链栈来说,如果节点间的链接出现错误,可能会导致整个链表的错误。

因此,我们需要更加细心地处理链表中的链接问题。

此外,我们还需提高编程技巧和细心程度,避免在实验过程中出现错误。

7.实验体会与展望通过本次实验,我们更加深入地理解了栈的性质及其操作,并掌握了链栈和顺序栈的实现方法。

我们还了解了两种数据结构的优缺点以及在实际应用中的适用场景。

在未来的学习和工作中,我们将继续深入学习数据结构及其相关领域的知识,以提高我们的编程能力和解决问题的能力。

同时,我们也将努力将所学的知识和技能应用于实际问题的解决中,以实现学以致用的目标。

数据结构栈实验报告

数据结构栈实验报告

一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型,熟练运用顺序栈和链栈进行基本操作,理解递归算法中栈的状态变化,并学会在计算机科学中应用栈解决实际问题。

二、实验内容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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验四、栈的顺序和链式存储的表示和实现实验目的:1.熟悉栈的特点(先进后出)及栈的基本操作,如入栈、出栈等。

2.掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现。

实验内容:1.栈的顺序表示和实现编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能。

(1)初始化顺序栈(2)插入一个元素(3)删除栈顶元素(4)取栈顶元素(5)遍历顺序栈(6)置空顺序栈#include <stdio.h>#include<stdlib.h>#define MAXNUM 20#define elemtype int//定义顺序栈的存储结构typedef struct{elemtype stack[MAXNUM];int top;}sqstack;//初始化顺序栈void initstack(sqstack *p){if(!p)printf("error");p->top=-1;}//入栈void push(sqstack *p,elemtype x) {if(p->top<MAXNUM-1){p->top=p->top+1;p->stack[p->top]=x;}elseprintf("\noverflow!\n");}//出栈elemtype pop(sqstack *p){elemtype x;if(p->top!=0){x=p->stack[p->top];printf(" 以前的栈顶数据元素%d 已经被删除!\n",p->stack[p->top]);p->top=p->top-1;return(x);}else{printf("栈为空\n");return(0);}}//获取栈顶元素elemtype gettop(sqstack *p){elemtype x;if(p->top!=-1){x=p->stack[p->top];return x;}else{printf("Underflow!\n");return 0;}}//遍历顺序栈void outstack(sqstack *p){int i;printf("\n");if(p->top<0)printf("这是一个空栈!\n");for(i=p->top;i>=0;i--)printf("第%d个数据元素是:%6d\n",i,p->stack[i]); }//置空顺序栈void setempty(sqstack *p){p->top=-1;}//主函数main(){sqstack *q;int y,cord;elemtype a;do{printf("\n第一次使用必须初始化!\n\n");printf("\n 主菜单\n");printf("\n 1 初始化顺序栈\n");printf("\n 2 插入一个元素\n");printf("\n 3 删除栈顶元素\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空顺序栈\n");printf("\n 6 结束程序运行\n");printf("\n----------------------------------\n");printf("请输入您的选择(1,2,3,4,5,6)");scanf("%d",&cord);printf("\n");switch(cord){case 1:{q=(sqstack *)malloc(sizeof(sqstack));initstack(q);outstack(q);}break;case 2:{printf("请输入要插入的数据元素:a=");scanf("%d",&a);push(q,a);outstack(q);}break;case 3:{pop(q);outstack(q);}break;case 4:{y=gettop(q);printf("\n栈顶元素为:%d\n",y);outstack(q);}break;case 5:{setempty(q);printf("\n顺序栈被置空! \n");outstack(q);}break;case 6:exit(0);}}while(cord<=6);}2.栈的链式表示和实现编写一个程序实现链栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能。

(1)初始化链栈(2)入栈(3)出栈(4)取栈顶元素(5)置空链栈(6)遍历链栈参考代码:#include <stdio.h>#include<stdlib.h>#include<malloc.h>#define null 0typedef int elemtype; typedef struct stacknode {elemtype data;stacknode *next;}stacknode;typedef struct{stacknode *top;}linkstack;//初始化链栈void initstack(linkstack *s){s->top=null;printf("\n已经初始化链栈!\n");}//链栈置空void setempty(linkstack *s){s->top=null;printf("\n链栈被置空!\n");}//入栈void pushlstack(linkstack *s,elemtype x) {stacknode *p=new stacknode;p->data=x;p->next=s->top;s->top=p;}//出栈elemtype poplstack(linkstack *s) {stacknode *p;elemtype e;p=s->top;if(s->top==null){printf("\n栈空\n");exit(-1);}e=p->data;s->top=p->next;delete p;return e;}//取栈顶元素elemtype stacktop(linkstack *s) {if(s->top==0){printf("\n链栈空\n");exit(-1);}return s->top->data;}//遍历链栈void disp(linkstack *s){printf("\n链栈中的数据位:\n");printf("===================================== ==\n");stacknode *p;p=s->top;while(p!=null){printf("%d\n",p->data);p=p->next;}printf("===================================== \n");}//主函数void main(){printf("链栈操作\n");int i,m,n,a;linkstack *s;s=(linkstack *)malloc (sizeof(linkstack));int cord;do{printf("\n第一次使用必须初始化!\n\n");printf("\n 主菜单\n");printf("\n 1 初始化链栈\n");printf("\n 2 入栈\n");printf("\n 3 出栈\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空链栈\n");printf("\n 6 结束程序运行\n");printf("\n----------------------------------\n");printf("请输入您的选择(1,2,3,4,5,6)");scanf("%d",&cord);printf("\n");switch(cord){case 1:{initstack(s);disp(s);}break;case 2:{printf("输入将要压入链栈的数据的个数:n="); scanf("%d",&n);printf("依次将%d个数据压入链栈:\n",n);for(i=1;i<=n;i++){scanf("%d",&a);pushlstack(s,a);}disp(s);}break;case 3:{printf("\n出栈操作开始!\n");printf("输入将要出栈的数据个数:m=");scanf("%d",&m);for(i=1;i<=m;i++){printf("\n第%d次出栈的数据是:%d\n",i,poplstack(s));}break;}case 4:{printf("\n\n链栈的栈顶元素为:%d\n\n",stacktop(s));}break;case 5:{setempty(s);disp(s);}break;case 6:exit(0);}}while(cord<=6);}实验总结:顺序栈初始化插入元素删除栈顶元素(此时栈中元素为1,2,3,4)取栈顶元素置空顺序栈链栈初始化入栈出栈取栈顶元素置空链表。

相关文档
最新文档