数据结构上机顺序栈建立
《数据结构》实验指导书
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType;//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础(广义表、树、图、查找、排序等)。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法(包括KMP算法)
typedef struct
{ElemType *base;
int front,rear;
} SqQueue;
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构
栈的工作原理
栈的工作原理
栈是一种特殊的数据结构,在其中元素的插入和删除操作仅在栈的一端进行。
栈遵循"先进后出"(LIFO)的原则,即最后
放入栈的元素最先被取出。
栈的工作原理可以简单概括为以下步骤:
1. 初始化:创建一个空栈。
2. 入栈:将元素依次插入到栈的顶部,也称作"压栈"或"推入"。
3. 出栈:从栈的顶部移除元素,也称作"弹出"。
4. 栈顶指针:栈顶指针指向当前栈顶元素。
初始时,栈为空,栈顶指针指向无效位置。
5. 栈空判断:通过检查栈顶指针是否指向无效位置,即可判断栈是否为空。
6. 栈满判断:栈的存储空间有限,当没有足够的空间继续入栈时,称栈为"栈满"。
可以通过检查栈顶指针是否指向最大容量
位置,判断栈是否已满。
7. 栈的末尾:栈的末尾是指栈顶元素所在的位置,也可以称为"栈顶"。
8. 栈的大小:栈的大小是指栈中元素的个数,可以通过栈顶指
针的位置来计算。
9. 栈的应用:栈在计算机科学中有广泛的应用,例如函数调用、表达式求值、括号匹配、迷宫求解等。
需要注意的是,在使用栈时需要遵循"先进后出"的原则,即新
元素只能插入到栈的顶部,也只能从顶部移除元素。
任何试图直接访问或修改栈的中间元素的操作都是无效的。
顺序栈的基本实现
顺序栈的基本实现
顺序栈是一种常见的数据结构,它遵循先进后出(Last In First Out)的原则。
在顺序栈中,元素通过顶部入栈和出栈。
实现顺序栈的基本步骤如下:
1. 定义一个固定大小的数组来存储栈元素。
可以使用静态数组或动态数组来实现,静态数组需要提前确定大小,而动态数组可以根据需要自动扩容。
2. 定义一个变量top来指示栈顶位置。
初始时,top的值为-1,表示栈为空。
3. 实现入栈操作push。
每次入栈,将栈顶指针top加1,并将元素放入数组的
对应位置。
4. 实现出栈操作pop。
每次出栈,将栈顶指针top减1,并返回对应位置的元素。
5. 实现获取栈顶元素操作getTop。
直接返回栈顶指针位置的元素。
6. 实现判断栈是否为空的操作isEmpty。
当栈顶指针top为-1时,表示栈为空,返回true;否则返回false。
使用顺序栈时,需注意栈空间是否已满,以免造成溢出。
如果使用静态数组实现,需提前确定栈的最大容量;如果使用动态数组实现,可在入栈时判断容量是否已满,并在需要时进行自动扩容。
顺序栈的基本实现可以用于许多实际应用,例如表达式求值、递归函数调用、
迷宫路径搜索等。
它提供了一种便捷的数据结构,能够高效地进行元素的插入和删除操作。
总之,顺序栈是一种基本的数据结构,通过数组和栈顶指针的操作,实现了元
素的入栈和出栈。
它在计算机科学中有着广泛的应用,是学习和理解更复杂数据结构的重要基础。
数据结构上机操作实验报告
实验一单链表的基本操作(必做)一、实验目的1.掌握单链表的存储、初始化、插入、删除等操作的程序实现。
2.加深对单链表基本概念,基本理论及相应算法的掌握与理解。
3.了解链表的处理方式,学习体会简单的单链表程序实现相关知识。
二、实验内容1.建立一个链表、设计链表的基本操作实现算法、输出一个链表表,调试并输出结果。
2.编写一个程序实现如下功能:让计算机产生出50个0~9之间的随机数并依次保存到单链表中;输出遍历单链表;从单链表中删除与给定值相等的所有结点;输出遍历单链表;输出单链表长度,调试并输出结果。
三、实验步骤1.定义一个链表结构体。
2.利用插入功能插入一个结点。
3.利用删除功能删除一个结点。
四、程序运行测试1.利用插入功能插入一个结点。
2.利用删除功能删除一个结点。
五、实验报告要求1.绘制链表操作实现的流程图。
2.详细给出程序运行测试结果(包括测试数据和测试结果)。
3.选试验步骤2-3中的任意一个,给出程序的详细注释。
4.参考程序中某一部分功能的改进(选做)5.实验心得与体会6.附录,实验用源程序六、参考源代码#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的单链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个单链表L,数据为整数,数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"在单链表内输入整数:"<<endl;for(int i=0;i<j;i++) p=(LinkList)malloc(sizeof(Lnode)); cin>>p->data;p->next=q->next;q->next=p;q=p; }int PrintLinkList(LinkList &L){//输出单链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"单链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算单链表L的数据元素个数。
栈的建立实验报告
一、实验目的本次实验旨在通过编程实现栈的顺序存储结构和链式存储结构,并熟练掌握栈的基本操作,包括栈的建立、入栈、出栈、取栈顶元素、判栈空等。
通过实验,加深对栈这一数据结构的理解,提高数据结构在实际问题中的应用能力。
二、实验内容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.栈的实现2.顺序栈的基本操作二、实验目的及要求熟悉栈的基本操作在顺序栈的实现。
通过具体应用实例在复习高级编程语言使用方法的基础上初步了解数据结构的应用。
三、设计分析与算法描述顺序栈的存储结构:typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化)int Push(SeqStack *S,int x)//进栈int Pop(SeqStack *S,int *x)//出栈int IsEmpty(SeqStack *S)//判栈是否空int IsFull(SeqStack *S)//判栈是否满int GetTop(SeqStack *S,int *x)//读栈顶四、附件:带注释的源程序#include"iostream.h"#define Stack_Size 50#define false 0#define true 1typedef struct{int elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S)//构造一个空栈(初始化) {S->top=-1;}int Push(SeqStack *S,int x)//进栈{if(S->top==Stack_Size-1)//栈已满return (false);S->top++;S->elem[S->top]=x;return (true);}int Pop(SeqStack *S,int *x)//出栈{if(S->top==-1)//栈已空return (false);else{*x=S->elem[S->top];S->top--;return (true);}}int IsEmpty(SeqStack *S)//判栈是否空{if(S->top==-1)return (true);elsereturn (false);}int IsFull(SeqStack *S)//判栈是否满{if(S->top==Stack_Size-1)return (true);elsereturn (false);}int GetTop(SeqStack *S,int *x)//读栈顶{if(S->top==-1)return (false);else{*x=S->elem[S->top];return (true);}}int main(){int i,temp;SeqStack st;InitStack(&st);for(i=0;i<10;i++)Push(&st,i);while(IsEmpty(&st)){Pop(&st,&temp);cout<<temp<<endl;}return 0;}。
北京交通大学-数据结构上机实验-2
数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求:可单独完成,也可两人一组。
评分标准:1) 只完成第一或第二题,3分;2)完成一和二题,得5分;3)在2)基础上,可选做三)中的题目。
题目:一)堆栈题(顺序栈):创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数,建立相应的堆栈,输入-1时,堆栈结束;(2)在(1)中创建的堆栈中添加一个元素;(3)在(1)中创建的堆栈中删除一个元素;(要求在显示器可见);#include<stdio.h>#include<stdlib.h>#include <string>#define OK 1#define ERROR 0#define Status int#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct Stack{int *base;int *top;Status stacksize;}SqStack;Status CreatStack(SqStack &S) //创建空栈{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status InStack(SqStack &S) //创建栈元素{int e;printf("请输入初始栈元素:\n");scanf("%d",&e);while(e!=-1){if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;scanf("%d",&e);}return OK;}Status Push(SqStack &S,int e) //栈加元素{if(S.top-S.base>=S.stacksize) //栈满,追加存储空间{S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(struct Stack));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,int e) //栈中删除元素{if(S.top==S.base) return ERROR;e=*--S.top;printf("\n请输出出栈元素:%d",e);printf("\n");return OK;}void print(){printf("\n菜单:");printf("\n1.由键盘一个一个的输入正整数,建立相应的堆栈,输入-1时,堆栈结束:");printf("\n2.在创建的堆栈中添加一个元素:");printf("\n3.在创建的堆栈中删除一个元素:");printf("\n3.退出");}void printS(SqStack &S) //打印堆栈{int *p;printf("请输出堆栈中的元素:\n");for(p=S.base;p<S.top;p++){printf("%d ",*p);}}void main() //主程序{SqStack S;int e,choice;do{print();printf("\n请输入选项:");scanf("%d",&choice);switch(choice){case 1:if(CreatStack(S)==1){if(InStack(S)==1)printS(S);}break;case 2:printf("\n请输入入栈元素:");scanf("%d",&e);Push(S,e);printS(S);break;case 3:Pop(S,e);printS(S);break;case 4:exit(0);break;}}while(1);}二)链队列题目:初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列;(2)在初始化好的链队列中放入数,入队列,完成后要求显示;(3)从队列中出队列,要求显示出来的元素和之后的队列;(4)销毁创建的队列,释放内存;#include <stdio.h>#include <malloc.h>typedef struct Qnode{//队列结点int data;struct Qnode *next;}QNode, *QueuePtr;typedef struct {QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;void InitQueue(LinkQueue &Q){ //初始化链队列Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode));Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int e){//入队列QueuePtr p;while(e!=-1){p=(QueuePtr)malloc(sizeof(QNode));p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;scanf("%d",&e);}}int QueueLength (LinkQueue Q){//求队列长度QueuePtr p;p=Q.front->next; //p指向队头int i=1;while(p!=Q.rear){ //遍历链队列,统计结点数i++;p=p->next;}return i;}// QueueLengthvoid DeQueue(LinkQueue &Q){ //出队列QueuePtr p;int e;if(Q.front==Q.rear)printf("The queue is empty\n");else{p=Q.front->next;e=p->data;printf("The delete elem is:%d\n",e);Q.front->next=p->next;if(Q.rear==p) Q.rear=Q.front;free(p);}printf("The new queue is :\n");}void DestroyQueue(LinkQueue &Q){ //销毁队列while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}}void QueueTraverse (LinkQueue Q){//遍历显示队列QueuePtr p;for(p=Q.front->next;p!=Q.rear;p=p->next)printf("%d ",p->data);printf("%d ",p->data);}void main(){LinkQueue Q;int e;InitQueue(Q);printf("Put in the elems:\n");scanf("%d",&e);EnQueue(Q,e);printf("The queue is:\n");QueueTraverse(Q);printf("\n");DeQueue(Q);QueueTraverse(Q);printf("\n");DestroyQueue(Q);}三)应用题(1)编制程序,将输入的十进制数据M 转换为八进制数据M8,将其调试通过。
数据结构实验报告顺序栈
数据结构实验报告顺序栈一、实验目的本次实验的主要目的是深入理解和掌握顺序栈这种数据结构的基本概念、操作原理以及在实际编程中的应用。
通过实际编写代码和进行实验操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。
二、实验环境本次实验使用的编程环境是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;}```出栈操作首先检查栈是否为空,如果非空,则取出栈顶元素,并更新栈顶指针。
数据结构实验二_栈的基本操作
青岛理工大学课程实验报告及实验步骤只要X不为0重复做下列动作将X%R入栈X=X/R只要栈不为空重复做下列动作栈顶出栈输出栈顶元素调试过程及实验结果根据输入的十进制数通过桟的基本操作可以转换成二进制、八进制、十六进制的数。
在上机过程中程序的调用没有太大的问题,按照课本的基本算法就可以将程序正确的运行。
总结程序可以完成基本的功能,可以将十进制数转换为其他进制的数,基本掌握了桟的几种常用的操作;但程序存在缺陷,就是不能持续进行操作,输入了一个十进制数只能进行一次数制转换,程序就会退出,有待改进。
附录#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack{int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;{return 0;}}int conversion(sqstack *s){int n,e=0,flag=0;printf("输入要转化的十进制数:\n");scanf("%d",&n);printf("要转化为多少进制:2进制、8进制、16进制填数字!\n");scanf("%d",&flag);printf("将十进制数%d转化为%d进制是:\n",n,flag);while(n){s->top=s->base;s->stacksize=stack_init_size;return 1;}int 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)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack *s,int e){if(s->top==s->base)return 0;e=*--s->top;return e;}int stackempty(sqstack *s){if(s->top==s->base){return 1;}elsePush(s,n%flag);n=n/flag;}while(!stackempty(s)) {e=Pop(s,e);switch(e){case 10: printf("A");break;case 11: printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e); }}printf("\n");return 0;}int main(){sqstack s;StackInit(&s); conversion(&s);return 0;}。
数据结构上机实验报告
数据结构上机实验报告学院:电子工程学院专业:信息对抗技术姓名:学号:教师:饶鲜日期:目录实验一线性表 ........................................................................................................ - 4 -一、实验目的.................................................................................................... - 4 -二、实验代码.................................................................................................... - 4 -三、实验结果.................................................................................................. - 14 -四、个人思路.................................................................................................. - 15 - 实验二栈和队列 .................................................................................................. - 15 -一、实验目的.................................................................................................. - 15 -二、实验代码.................................................................................................. - 16 -三、实验结果.................................................................................................. - 24 -四、个人思路.................................................................................................. - 25 - 实验三数组 .......................................................................................................... - 26 -一、实验目的.................................................................................................. - 26 -二、实验代码.................................................................................................. - 26 -三、实验结果.................................................................................................. - 28 -四、个人思路.................................................................................................. - 28 - 实验四树 .............................................................................................................. - 29 -一、实验目的.................................................................................................. - 29 -二、实验代码.................................................................................................. - 29 -三、实验结果.................................................................................................. - 39 -四、个人思路.................................................................................................. - 39 -实验一线性表一、实验目的1.熟悉线性表的顺序和链式存储结构2.掌握线性表的基本运算3.能够利用线性表的基本运算完成线性表应用的运算二、实验代码1.设有一个线性表E={e1, e2, … , e n-1, e n},设计一个算法,将线性表逆置,即使元素排列次序颠倒过来,成为逆线性表E’={ e n, e n-1 , … , e2 , e1 },要求逆线性表占用原线性表空间,并且用顺序表和单链表两种方法表示,分别用两个程序来完成。
数据结构栈和队列上机报告
数据结构栈和队列一上机的目的和要求实验目的:1.掌握实现栈/队列的基本操作方法2.掌握栈的基本操作:建栈,Push,Pop等运算在顺序存储上的实现3.掌握队列的基本操作:建队列,入队,出队等运算在顺序存储结构上的实现队列的实验参照栈编程实现。
实验报告要求:1. 上机前完成所有的函数编写2.实验记录部分填写编写主函数调用所写所有函数的屏幕输出3.实验总结部分填写对该次实验所编写函数的运行情况,和在实验过程中对栈的认识和实现情况二基本知识和原理栈和队列是两种常用的数据结构,栈和队列是操作受限的线性表,栈和队列的数据元素具有单一的前驱和后继的线性关系;栈和队列又是两种重要的抽象数据类型。
栈是限定在表尾进行插入和删除操作的线性表允许插入和删除的一端为栈顶,另一端为栈底,出栈元素只能是栈顶元素,后进先出,相邻元素具有前驱与后继关系。
队列是只允许在一端进行插入操作,在另一端进行删除操作的线性表。
允许插入的一端为队尾,允许删除的一端为队头,先进先出,相邻元素具有前驱与后继关系。
三程序算法分析及实现代码#include"stdio.h"#include"conio.h"#define MaxSize 100 /*栈中的元素的最大个数*/typedef int ElemType;typedef struct{ElemType data[MaxSize];/*存放堆栈的数组*/int top;/*栈顶元素*/}Stack,*S;/*堆栈的初始化*/void InitStack(Stack *S){/*指向的是最顶端的元素取值范围为从0~MaxSize-1为-1时说明为空栈*/S->top=-1;}int StackEmpty(SqStack *s) //判断是否为空{if(s->top==s->base){return TRUE;}else{return 0;}}int GetTop(SqStack* s,int *e) //取栈顶{//若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERRORif(s->top==s->base){return ERROR;}*e=*(s->top-1);return 1;}int Push(SqStack *s,int e) //进栈{//插入元素e为新的栈顶元素if(s->top-s->base>=s->stacksize){//栈满,追加存储空间s->base=(int *)malloc(SIZE*sizeof(int));if(!s->base)exit(OVERFLOW);s->top=s->base + s->stacksize;s->stacksize +=SIZE;}*(s->top)++=e;return 1;}int Pop(SqStack *s ,int *e)//出栈{// 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORif(s->base == s->top)return ERROR;*e = *--s->top;return 1;}int main ( ){SqStack sq;InitStack(&sq);int e;int N;int k;int n=0;Z:{printf("\n\t********************************************");printf("\n\t*** 请你输入相应的操作序号进行操作 ***");printf("\n\t*** 1.是否空 ***");printf("\n\t*** 2.取栈顶元素 ***");printf("\n\t*** 3.进栈 ***");printf("\n\t*** 4.出栈 ***");printf("\n\t*** 0. 退出 ***\n");printf("\t********************************************");printf("\n请选择功能:");scanf("%d",&k);switch(k){case 1:if(StackEmpty(&sq)){printf("该栈为空!");}else{printf("该栈非空!");}goto Z;break;case 2:GetTop(&sq, &e);printf("栈顶元素为:%d", e);goto Z;break;case 3:printf("请输入要进栈的元素:");scanf("%d", &e);Push(&sq, e);goto Z;break;case 4:Pop(&sq,&e);printf("%d", e);goto Z;break;case 0:exit(0);break;default:break;}}}二队列#include<iostream>#include<malloc.h>using namespace std;#define TRUE 1#define FLASE 0#define OK 1typedef struct QNode {char data;struct QNode *next;}QNode, *Queue;typedef struct {Queue front;Queue rear;}LinkQueue;void InitQueue(LinkQueue &Q)//创造空队{Q.front = Q.rear = (Queue)malloc(sizeof(QNode));if (!Q.front){printf("OVERFLOW" );}Q.front->next = NULL;// return OK;}void EnQueue(LinkQueue &Q, int e)//入队{Queue p = (Queue)malloc(sizeof(QNode));p->data = e;p->next = NULL;Q.rear->next = p;Q.rear = p;//return OK;}void DeQueue(LinkQueue &Q, int e)//出队{Queue p = (Queue)malloc(sizeof(QNode));if (Q.front == Q.rear){p rintf("队空");}p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front;free(p);printf( " 元素已经出队");}int length(LinkQueue &Q)//求队列中元素个数{Queue p = (Queue)malloc(sizeof(QNode));p = Q.front->next;int i = 0;while (p != NULL){p = p->next;i++;}printf("队列中元素个数: ");printf(”%d”,i );return 1;}int QueueEmpty(LinkQueue &Q)//判队列空{if (Q.front == Q.rear)return TRUE;elsereturn FLASE;}int main(){LinkQueue Q;int k;Z:{printf(" \n\t********************************************");printf( "\n\t*** 请你输入相应的操作序号进行操作 ***");printf( "\n\t*** 1.初始化 ***");printf( "\n\t*** 2.入队 ***");printf( "\n\t*** 3.出队 ***");printf( "\n\t*** 4.求队列中元素个数 ***");printf( "\n\t*** 5.判队列是否为空 ***");printf( "\n\t********************************************");printf( "\n请选择功能:");cin >> k;switch (k){case 1:InitQueue(Q);goto Z;break;case 2:printf("请输入要插入的元素");int e;cin >> e;EnQueue(Q, e);goto Z;break;case 3:printf( "出队");int m;DeQueue(Q, m);goto Z;break;case 4:length(Q);goto Z;break;case 5:if (QueueEmpty(Q))printf("队列为空");elseprintf("队列不为空");goto Z;break;default:break;}}}四结果分析及测试相关记录队列入队求队列中元素个数出队列判断是否为空五实验体会和学习感悟学习完队列和栈一章后对其操作还有基本函数的运用有了基本的了解。
数据结构上机作业——顺序表
数据结构上机作业——顺序表一、实验目的理解线性表的逻辑结构、顺序存储结构和数据操作,熟练运用Java语言实现线性表的基本操作,分析各种操作算法特点和时间复杂度。
熟悉JCreator调试程序的方法。
二、主要内容1、按照教材P37编写顺序表类,在SeqList中增加main方法或者编写一个测试类测试各方法的正确性。
说明:注意package路径,导入LList,过程参考如下:1)创建工程:File->New->Project,选择Empty Project,输入工程名称及路径,点击完成。
2)鼠标指向工程ds,单击鼠标右键,在快捷菜单中选择Add->New Folder,新建文件夹dataStructure,在dataStructure新建文件夹linearList。
3)鼠标指向文件夹linearList,单击鼠标右键,在快捷菜单中选择Add Existing Files,选择LList.java(教育在线例程中)。
4)鼠标指向文件夹linearList,单击鼠标右键,,在快捷菜单中选择New Class,在Class Wizard中输入相关内容,类名:SeqList。
5)程序编辑结束后,执行Build->Build File菜单命令,编译Java程序,系统在Build Output区域输出错误信息,编译通过后将生成字节码文件(.class)。
6)测试:方法1 在SeqList类中增加main方法,例如public static void main(String args[]){SeqList<String> list=new SeqList<String>(7);list.add("");list.add("");list.add("");list.add("");System.out.println(list.toString());list.add(2,"");System.out.println(list.toString());list.remove(3);System.out.println(list.toString());}修改main方法,完成相应测试。
《数据结构》实验指导书(Java语言版).
《数据结构》课程实验指导《数据结构》实验教学大纲课程代码:0806523006 开课学期:3 开课专业:信息管理与信息系统总学时/实验学时:64/16 总学分/实验学分:3.5/0.5一、课程简介数据结构是计算机各专业的重要技术基础课。
在计算机科学中,数据结构不仅是一般程序设计的基础,而且是编译原理、操作系统、数据库系统及其它系统程序和大型应用程序开发的重要基础。
数据结构课程主要讨论各种主要数据结构的特点、计算机内的表示方法、处理数据的算法以及对算法性能的分析。
通过对本课程的系统学习使学生掌握各种数据结构的特点、存储表示、运算的原理和方法,学会从问题入手,分析研究计算机加工的数据结构的特性,以便为应用所涉及的数据选择适当的逻辑结构、存储机构及其相应的操作算法,并初步掌握时间和空间分析技术。
另一方面,本课程的学习过程也是进行复杂程序设计的训练过程,通过对本课程算法设计和上机实践的训练,还应培养学生的数据抽象能力和程序设计的能力。
二、实验的地位、作用和目的数据结构是一门实践性较强的基础课程,本课程实验主要是着眼于原理和应用的结合,通过实验,一方面能使学生学会把书上学到的知识用于解决实际问题,加强培养学生如何根据计算机所处理对象的特点来组织数据存储和编写性能好的操作算法的能力,为以后相关课程的学习和大型软件的开发打下扎实的基础。
另一方面使书上的知识变活,起到深化理解和灵活掌握教学内容的目的。
三、实验方式与基本要求实验方式是上机编写完成实验项目指定功能的程序,并调试、运行,最终得出正确结果。
具体实验要求如下:1.问题分析充分地分析和理解问题本身,弄清要求,包括功能要求、性能要求、设计要求和约束,以及基本数据特性、数据间联系等等。
2.数据结构设计针对要解决的问题,考虑各种可能的数据结构,并且力求从中选出最佳方案(必须连同算法实现一起考虑),确定主要的数据结构和全程变量。
对引入的每种数据结构和全程变量要详细说明其功用、初值和操作的特点。
数据结构上机实验指导
《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。
设计和验证顺序表的查找、插入、删除算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成顺序表。
并将创建好的顺序表元素依次打印在屏幕上。
(2)设计一个带选择菜单的主函数,菜单中具备任意选择删除、插入、查找数据元素的功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置或元素值,按指定方式删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号。
(4)每种操作结束后,都能在屏幕上打印出此时顺序表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
2、上机编写程序。
3、编译。
4、调试。
例程:书上参考算法2-1,2-4,2-5,2-6,2-8!带菜单的主函数参考书上2.5综合实例!注意:顺序表的结构体!typedef struct{datatype items[listsize];int length;}SpList;实验二【实验名称】单链表的基本算法【实验目的】创建一个单链表,掌握线性表链式存储的特点。
设计和验证链表的查找、插入、删除、求表长的算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成单链表。
并将创建好的单链表元素依次打印在屏幕上。
(注意:选择头插法或者尾插法!)(2)设计一个带选择功能菜单的主函数,菜单中至少具备任意选择删除、插入、查找数据元素,和求单链表表长等几项功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置,按指定位置删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号;当选择求表长功能时,返回该单链表表长的数值。
(4)每种操作结束后,都能在屏幕上打印出此时单链表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
C语言数据结构之栈的基本操作
C语言数据结构之栈的基本操作栈是一种特殊的数据结构,它按照后进先出(LIFO)的原则进行操作。
栈可以用数组或链表来实现,下面将介绍栈的基本操作。
1.初始化栈:栈的初始化就是为栈分配内存空间,并将栈顶指针设置为-1(如果是数组实现)或者NULL(如果是链表实现)。
2.判断栈空:栈空表示栈中没有任何元素。
如果栈顶指针等于-1或者NULL,则表示栈空。
3.判断栈满:栈满表示栈中已经存满了元素。
如果栈顶指针等于栈的最大容量减1,则表示栈满。
4. 进栈(push):进栈操作就是将元素放入栈中。
如果栈不满,则将栈顶指针加1,并将元素放入栈顶位置。
5. 出栈(pop):出栈操作就是从栈中取出一个元素。
如果栈不空,则将栈顶指针减1,并返回栈顶元素。
6. 获取栈顶元素(getTop):获取栈顶元素操作不改变栈的状态,只返回栈顶元素的值。
如果栈不空,则返回栈顶元素值;否则,返回空值。
7.清空栈:清空栈操作就是将栈中的所有元素全部出栈,即将栈顶指针设置为-1或者NULL。
8.销毁栈:销毁栈操作是释放栈的内存空间,将栈的指针设置为NULL。
栈的应用:栈在计算机领域有广泛的应用,其中一个常见的应用是函数调用栈。
当一个函数调用另一个函数时,当前函数的状态(包括局部变量、返回地址等)会被压入到栈中。
当被调用函数执行完成后,栈顶的元素会被弹出,然后继续执行调用该函数的代码。
另一个常见的应用是表达式求值。
在表达式求值过程中,需要用到运算符优先级。
我们可以利用栈来处理运算符的优先级。
将运算符入栈时,可以先与栈顶运算符比较优先级,如果栈顶运算符的优先级高于当前运算符,则将栈顶运算符出栈,并继续比较。
这样可以确保栈中的运算符按照优先级从高到低的顺序排列。
此外,栈还可以用于处理括号匹配问题。
当遇到左括号时,将其入栈;当遇到右括号时,判断栈顶元素是否为对应的左括号,如果是,则将栈顶元素弹出,否则表示括号不匹配。
如果最后栈为空,则表示所有括号都匹配。
数据结构上机实验题
数据结构上机实验题数据结构实验⼀线性表270。
实验⽬的:1.熟悉C语⾔的上机环境,进⼀步掌握C语⾔的结构特点。
2.掌握线性表的顺序存储结构的定义及C语⾔实现。
3.掌握线性表的链式存储结构——单链表的定义及C语⾔实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
实验内容:1.顺序线性表的建⽴、插⼊及删除。
2.链式线性表的建⽴、插⼊及删除。
实验步骤:1.建⽴含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利⽤前⾯的实验先建⽴⼀个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插⼊元素68。
3.建⽴⼀个带头结点的单链表,结点的值域为整型数据。
要求将⽤户输⼊的数据按尾插⼊法来建⽴相应单链表。
实现提⽰:1.由于C语⾔的数组类型也有随机存取的特点,⼀维数组的机内表⽰就是顺序结构。
因此,可⽤C语⾔的⼀维数组实现线性表的顺序存储。
在此,我们利⽤C语⾔的结构体类型定义顺序表:#define MAXSIZE 1024-可编辑修改-typedef int elemtype; /* 线性表中存放整型元素*/typedef struct{elemtype vec[MAXSIZE];int len; /* 顺序表的长度*/}sequenlist;将此结构定义放在⼀个头⽂件sqlist.h⾥,可避免在后⾯的参考程序中代码重复书写,另外在该头⽂件⾥给出顺序表的建⽴及常量的定义。
2. 注意如何取到第i个元素,在插⼊过程中注意溢出情况以及数组的下标与位序(顺序表中元素的次序)的区别。
3.单链表的结点结构除数据域外,还含有⼀个指针域。
⽤C语⾔描述结点结构如下:typedef int elemtype;typedef struct node{elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建⽴⽅法及构造新结点时指针的变化。
数据结构实验报告栈及其应用docx
引言概述:正文内容:一、栈的概念和基本特性1.1栈的定义栈是一种操作受限的线性表,只允许在一端进行插入和删除操作,该端称为栈顶,另一端称为栈底。
栈的特点是“后进先出”(LIFO,LastInFirstOut)。
1.2栈的基本操作栈包含几个基本操作,如入栈(Push)、出栈(Pop)、判空(IsEmpty)、判满(IsFull)等。
二、栈的顺序存储结构实现方式2.1顺序存储结构的定义栈的顺序存储结构是利用一组地质连续的存储单元依次存储栈中的元素。
数组可以作为栈的顺序存储结构进行实现。
2.2顺序存储结构的入栈操作入栈操作需要将新元素插入栈顶,并更新栈顶指针。
2.3顺序存储结构的出栈操作出栈操作需要删除栈顶元素,并更新栈顶指针。
三、栈的链式存储结构实现方式3.1链式存储结构的定义栈的链式存储结构是利用链表实现栈的存储结构。
每个链表节点包含存储元素的数据域和指向下一个节点的指针域。
3.2链式存储结构的入栈操作入栈操作需要创建一个新节点并插入到链表头部,并更新栈顶指针。
3.3链式存储结构的出栈操作出栈操作需要删除链表头节点,并更新栈顶指针。
四、栈的应用4.1递归算法栈常用于实现递归算法,通过将递归函数的参数和局部变量保存在栈中,实现递归函数的调用和返回。
4.2括号匹配栈可以判断表达式中的括号是否匹配,通过入栈和出栈操作进行括号的匹配过程。
4.3后缀表达式求值栈可以用来实现后缀表达式的求值过程,通过入栈和出栈操作计算后缀表达式的值。
五、总结本文详细讨论了栈的概念、特性、实现方式和应用。
通过了解栈的基本操作,我们可以更好地理解栈的原理和使用。
栈在计算机科学领域具有广泛的应用,对于实现递归算法、括号匹配和后缀表达式求值等问题都有重要作用。
对于进一步的学习和实践,我们需要深入理解栈的原理和实现方式,并能熟练运用栈解决问题。
希望本文能为读者对栈及其应用有一个清晰的认识。
华南农业大学数据结构上机答案实验
华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈,并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。
请将下#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef int SElemType; // 定义栈元素类型typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK 等struct SqStack{SElemType *base; // 在栈构造之前和销毁之后,base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间,以元素为单位}; // 顺序栈Status InitStack(SqStack &S){// 构造一个空栈S,该栈预定义大小为STACK_INIT_SIZE// 请补全代码S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEl emType));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){// 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){// 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR // 请补全代码if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){// 返回栈S的元素个数// 请补全代码return S.top-S.base;}Status StackTraverse(SqStack S){// 从栈顶到栈底依次输出栈中的每个元素SElemType *p = (SElemType *)malloc(sizeof(SElemType));p = S.top ; //请填空if(S.top==S.base)printf("The Stack is Empty!"); //请填空else{printf("The Stack is: ");p--;while(p>=S.base) //请填空{printf("%d ", *p);p--; //请填空}}printf("\n");return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功,请填空{printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d", &x);if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法,请填空else printf("The Element %d is Successfully Pushed!\n", x); break;case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法,请填空else printf("The Element %d is Successfully Poped!\n", e); break;case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top 是否合法,请填空else printf("The Top Element is %d!\n", e);break;case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列,并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。
数据结构实验—顺序栈的实现
实验四顺序栈的操作一.实验目的掌握顺序栈的基本操作:初始化栈、判栈空、入栈、出栈、取栈顶数据元素等运算及程序实现方法。
二.实验内容(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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
};
Status InitStack(SqStack &S){
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base) exit(OVERFLOW);
1.
顺序栈的建立及基本操作实现,要求建立一个顺序栈,并且执行初始化、入栈、出栈、栈的清空、栈中元素计数等功能。
2.
本次程序设计要求建立一个顺序栈,并且执行初始化、入栈、出栈、栈的清空、栈中元素计数等功能。
(1)输入形式为从键盘输入,用户根据界面的提示从键盘直接输入所对应的数即可。输入的值为正数或字符,用户输入其他的数据会产生错误。
(2)系统按照用户输入的数据类型,将会把相应的输出结果显示到界面上。
(3)测试:按照提示建立一个单链表,按照提示进行初始化、入栈、出栈、栈的清空、栈中元素计数等操作测试程序是否正确。
3.
(1)数据结构定义:
#include "stdio.h"
#include "stdlib.h"
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
输入输出如截图:
8.
//顺序栈
#include "stdio.h"
#include "stdlib.h"
#define STACK_INIT_SIZE 10 //存储空间初始分配量
#define STACKINCREMENT 2 //存储空间分配增量
#define OVERFLOW -2
#define OK 1
6.
1 建立顺序栈:先输入顺序栈的元素个数,按ENTER键,输入第一个元素后,再按ENTER键换行输入第二个元素,同样操作进行下面。
2 选项2是测试顺序栈是否为空。
3 输入3选项是计算栈长度。
4 选项4是读出栈顶元素。
5 选项5元素出栈。
6 选项6是销毁栈。
7.
采用测试数据,列出实际的输入、输出结果。
S.top--;
e=*S.top ;
return OK;
}/
检验栈是否为空
Status StackEmpty(SqStack &S){
if(S.top==S.base) printf("栈为空");
else
printf("栈不为空");
return OK;
}
用e返回s的栈顶元素
Status GetTop(SqStack &S,SElemType &e){
}
}
return OK;
}//GetTop
Status StackLength(SqStack &S){
if(S.base==NULL) return ERROR;
else
printf("栈长为%d",S.top-S.base);
return OK;
}//StackLength
Status ClearStack(SqStack &S){
if(!S.base)exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
删除栈顶元素用e返回
Status Pop(SqStack &S,SElemType &e){
if(S.top==S.base) return ERROR;
用伪码给出主程序的主要处理过程。
4.
InitStack(&S)构造一个空栈。
Push(&S,e)插入元素为e的新栈顶。
Pop(&s,&e)删除栈顶元素用e返回
ClearStack(&s)清空栈
StackEmpty(s)栈是否为空
GetTop(s,&e)用e返回s的栈顶元素
StackLength(&s)计算栈长度
printf("\n请输入选项:");
scanf("%d",&n);
return n;
}//menu
void main()
{
int n;
SElemType e;
SqStack s;
InitStack(s);
n=menu();
while(n)
{
switch(n)
{
case 1:
int i;
printf("请输入要进栈的元素个数:\n");
else
printf("栈不为空");
return OK;
}//Empty
Status GetTop(SqStack &S,SElemType &e){
char *p=S.top ;
if(S.top==S.base) {printf("栈为空");return ERROR;}
p--;
e=*p;
printf("\n栈顶元素为:%d",*p);
StackLength(s);
break;
case 4:
GetTop(s,e);源自break;case 5:
Pop(s,e);
break;
case 6:
ClearStack(s);
break;
case 0:
exit(0);
}//switch
printf("\n请输入选项:");
scanf("%d",&n);
#define ERROR 0
typedef int Status;
typedef char SElemType; //定义栈元素类型
//顺序栈
struct SqStack
{
SElemType *base; //在栈构造之前和销毁之后,base的值为NULL
SElemType *top; //栈顶指针
#define STACKINCREMENT 2 // 存储空间分配增量
#define OVERFLOW -2
#define OK 1
#define ERROR 0
typedef int Status;
typedef char SElemType; // 定义栈元素类型
(2)画出各模块之间的调用关系图。
scanf("%d",&n); InitStack(s);
printf("请输入%d个数:\n",n);
for( i=1;i<=n;i++)
{ scanf("%d",&e); Push(s,e); }
Push(s,e);
break;
case 2:
StackEmpty(s);
break;
case 3:
Status Pop(SqStack &S,SElemType &e){
if(S.top==S.base) return ERROR;
S.top--;
e=*S.top ;
return OK;
}//Pop
Status StackEmpty(SqStack &S){
if(S.top==S.base) printf("栈为空");
printf("\n1.元素入栈2.测试栈是否为空");
printf("\n3.计算栈长4.取出栈顶元素");
printf("\n5.元素出栈6.清空栈");
printf("\0.退出\n");
printf("\n**************************************\n");
(2)主要伪代码:
插入元素为e的新栈顶。
Status Push(SqStack &S){
if(S.top-S.base>=S.stacksize){
S.base=(SElemType*)realloc(S.base,
(S.stacksize+=STACKINCREMENT)*sizeof(SElemType));
if(S.base=NULL) return ERROR;
else
{S.top=S.base;
printf("栈已清空");}
return OK;
}//ClearStack
int menu()
{
int n;
printf("\n主菜单");
printf("\n**************************************");
(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}
if(S.top==S.base) return ERROR;
p--;
e=*p;