数据结构C语言版顺序栈上机实验

C语言数据结构中栈操作实验C语言数据结构中栈操作实验c语言中栈是一种数据结构，后进先出，即最后进入栈的数据最先弹出。

以下是店铺搜索整理的关于C语言数据结构中栈操作实验，需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!实验：编写一个程序实现顺序栈的各种基本运算，并在此基础上设计一个主程序，完成如下功能：（1）初始化顺序栈（2）插入元素（3）删除栈顶元素（4）取栈顶元素（5）遍历顺序栈（6）置空顺序栈分析:栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。

对于顺序栈，入栈时，首先判断栈是否为满，栈满的`条件为：p->top= =MAXNUM-1，栈满时，不能入栈; 否则出现空间溢出，引起错误，这种现象称为上溢。

出栈和读栈顶元素操作，先判栈是否为空，为空时不能操作，否则产生错误。

通常栈空作为一种控制转移的条件。

注意：（1）顺序栈中元素用向量存放（2）栈底位置是固定不变的，可设置在向量两端的任意一个端点（3）栈顶位置是随着进栈和退栈操作而变化的，用一个整型量top（通常称top为栈顶指针）来指示当前栈顶位置顺序栈的实现：#include <stdio.h>#include <malloc.h>typedef int SElemType;typedef int Status;#define INIT_SIZE 100#define STACKINCREMENT 10#define Ok 1#define Error 0#define True 1#define False 0typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;//初始化栈Status InitStack(SqStack *s){s->base = (SElemType *)malloc(INIT_SIZE * sizeof(SElemType));if(!s->base){puts("存储空间分配失败！");return Error;}s->top = s->base;s->stacksize = INIT_SIZE;return Ok;}//清空栈Status ClearStack(SqStack *s)s->top = s->base;return Ok;}//栈是否为空Status StackEmpty(SqStack *s){if(s->top == s->base)return True;elsereturn False;}//销毁栈Status Destroy(SqStack *s){free(s->base);s->base = NULL;s->top = NULL;s->stacksize=0;return Ok;}//获得栈顶元素Status GetTop(SqStack *s, SElemType &e) {if(s->top == s->base) return Error;e = *(s->top - 1);return Ok;}//压栈Status 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){puts("存储空间分配失败！");return Error;}s->top = s->base + s->stacksize;//修改栈顶位置s->stacksize += STACKINCREMENT;//修改栈长度}*s->top++ = e;return Ok;}//弹栈Status Pop(SqStack *s, SElemType *e){if(s->top == s->base) return Error;--s->top;*e = *(s->top);return Ok;}//遍历栈Status StackTraverse(SqStack *s,Status(*visit)(SElemType)){SElemType *b = s->base;//此处不能直接用base或top移动，即不能改变原栈的结构SElemType *t = s->top;while(t > b)visit(*b++);printf(" ");return Ok;}Status visit(SElemType c) {printf("%d ",c);return Ok;}测试代码：int main(){SqStack a;SqStack *s = &a; SElemType e;InitStack(s);int n;puts("请输入要进栈的个数："); scanf("%d", &n);while(n--){int m;scanf("%d", &m);Push(s, m);}StackTraverse(s, visit);puts("");puts("8进栈后：");Push(s, 8);StackTraverse(s, visit);puts("");Pop(s, &e);printf("出栈的元素是：%d ", e);printf("元素出栈后事实上并没有清除，依然存在于内存空间，所谓的出栈只是指针移动，出栈的元素是%d ", *s->top);//判断出栈后元素是否还存在于内存中Destroy(s);return 0;}运行结果：。

数据结构实验实验内容和目的：掌握几种基本的数据结构：集合、线性结构、树形结构等在求解实际问题中的应用，以及培养书写规范文档的技巧。

学习基本的查找和排序技术。

让我们在实际上机中具有编制相当规模的程序的能力。

养成一种良好的程序设计风格。

实验教材：数据结构题集（C语言版）清华大学出版社2007年实验项目：实验一、栈和循环队列㈠、实验内容：①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。

本程序采用的是链栈结构，具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。

②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，学会循环队列的实现，以便在实际问题背景下灵活运用。

本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。

㈡、实验代码①栈程序代码：#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果：②循环队列程序代码：#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为：\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为：\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果：实验二、数组㈠、实验内容：数组一般不做插入或删除操作，也就是说，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。

顺序栈实验报告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 获取栈顶元素获取栈顶元素不改变栈的结构，只需要返回栈顶指针对应的元素即可。

《数据结构与算法》实验报告一、实验内容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;}。

数据结构实验三课程数据结构实验名称顺序栈基本操作第页专业班级学号姓名实验日期：年月日评分一、实验目的1．熟悉并能实现栈的定义和基本操作。

2．了解和掌握栈的应用。

二、实验要求1．进行栈的基本操作时要注意栈"后进先出"的特性。

2．编写完整程序完成下面的实验内容并上机运行。

3．整理并上交实验报告。

三、实验内容1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。

2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术表达式的值。

主要功能描述如下：（1）从键盘上输入表达式。

（2）分析该表达式是否合法：•a) 是数字，则判断该数字的合法性。

若合法，则压入数据到堆栈中。

•b) 是规定的运算符，则根据规则进行处理。

在处理过程中，将计算该表达式的值。

•c) 若是其它字符，则返回错误信息。

（3）若上述处理过程中没有发现错误，则认为该表达式合法，并打印处理结果。

程序中应主要包含下面几个功能函数：•l void initstack()：初始化堆栈•l int Make_str()：语法检查并计算•l int push_operate(int operate)：将操作码压入堆栈•l int push_num(double num)：将操作数压入堆栈•l int procede(int operate)：处理操作码•l int change_opnd(int operate)：将字符型操作码转换成优先级•l int push_opnd(int operate)：将操作码压入堆栈•l int pop_opnd()：将操作码弹出堆栈•l int caculate(int cur_opnd)：简单计算+，-，*，/•l double pop_num()：弹出操作数四、实验步骤（描述实验步骤及中间的结果或现象。

在实验中做了什么事情，怎么做的，发生的现象和中间结果）第一题：#include <iostream>using namespace std;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量#define OVERFLOW -1#define OK 1#define NO -1#define NULL 0typedef int Status;typedef char SElemType;typedef struct{SElemType *base; //在栈构造之前和销毁之后，base的值为NULLSElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位} SqStack;Status Initstack(SqStack &S)//构造一个空栈S{S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base)exit(OVERFLOW);S.top=S.base;S.stacksize= STACK_INIT_SIZE;return OK;}//InitStackStatus StackEmpty(SqStack &S){if(S.base==S.top)return OK;elsereturn NO;}Status ClearStack (SqStack &S)//把S置为空{if(S.base=S.top);return OK;}Status DsetroyStack (SqStack &S)//销毁栈S{S.base=NULL;return OK;}Status Push(SqStack &S,SElemType e)//插入元素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 &c)//若栈不空，则删除S的栈顶元素，用c返回其值，并返回OK；否则返回ERROR {if(S.top==S.base)return NO;c=*--S.top;return OK;}//PopStatus GetTop(SqStack &S,SElemType &e){if (S.top==S.base)return NO;e=*(S.top-1);return OK;}//GetTopint main(){SqStack S;Initstack(S);cout<<"输入要压到栈中的元素!"<<endl;char c;while((c=getchar())!='\n'){Push(S,c);}GetTop(S,c);cout<<"栈顶元素为："<<c<<endl;//ClearStack (S);//DsetroyStack(S);for(int i=0;S.top!=S.base;i++){Pop(S,c);cout<<"栈中第"<<i+1<<"元素的值:";cout<<c<<endl;}return 0;}第二题：#include<iostream>using namespace std;#define STACK_SIZE 100#define STACKINCREMENT 10#define OVERFLOW -1#define OK 1#define NO 0typedef int Status;typedef char SElemType;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;int main(){char GetTop(SqStack &s);Status Initstack(SqStack &s);Status push_operate(SqStack &s,SElemType e);Status push_num(SqStack &s,int e);Status Stackempty(SqStack &s);Status pop_num(SqStack &s,int &c);Status pushoperate(SElemType operate);Status pushnum(SElemType num);Status caculate(SElemType a,SElemType operate,SElemType b);Status pop_operate(SqStack &s,SElemType &c);Status change(SElemType e);char Precede(SElemType a,SElemType b);char Operatecxz();int m;m=Operatecxz();cout<<m<<endl;return 0;}Status change(SElemType e){int m;m=e-48;return m;}Status Initstack(SqStack &s){s.base=(SElemType *)malloc(STACK_SIZE*sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_SIZE;return OK;}Status Stackempty(SqStack &s){if(s.base==s.top)return OK;elsereturn NO;}Status push_num(SqStack &s,int 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;}Status push_operate(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;}Status pop_operate(SqStack &s,SElemType &c){if(s.top==s.base)return NO;c=*--s.top;return OK;}Status pop_num(SqStack &s,int &c){if(s.top==s.base)return NO;c=*--s.top;return OK;}char GetTop(SqStack &s){char c;if(s.top==s.base)return NO;c=*(s.top-1);return c;}Status caculate(int a,SElemType operate,int b){int s;if(operate=='+')s=a+b;if(operate=='-')s=a-b;if(operate=='*')s=a*b;if(operate=='/')s=a/b;return s;}Status In(SElemType c){if(c=='+'||c=='-'||c=='*'||c=='/'||c=='#'||c=='('||c==')') return OK;if(c>='0'&&c<='9')return NO;return -1;}char Precede(SElemType a,SElemType b){if(a=='+'||a=='-'){if(b=='+'||b=='-'||b==')'||b=='#')return '>';if(b=='*'||b=='/'||b=='(')return '<';}if(a=='*'||a=='/'){if(b=='+'||b=='-'||b==')'||b=='*'||b=='/'||b=='#')return '>';if(b=='(')return '<';}if(a=='('){if(b==')')return '=';if(b=='+'||b=='-'||b=='*'||b=='/')return '<';if(b=='#')return ' ';}if(a==')'){if(b==')')return ' ';if(b=='+'||b=='-'||b=='*'||b=='/'||b=='('||b=='#')return '>';}if(a=='#'){if(b=='#')return '=';if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')return '<';if(b==')')return ' ';}return ' ';}char Operatecxz(){SqStack Operate,Num;char c,e,x;int num,a,b,flat=1,sz=0;Initstack(Operate);push_operate(Operate,'#');Initstack(Num);c=getchar();while(c!='#'||GetTop(Operate)!='#'){if(In(c)==-1){cout<<"input error!"<<endl;flat=0;break;}if(In(c)!=1){if(sz==0){num=change(c);sz=1;c=getchar();continue;}if(sz==1)num=num*10+change(c);c=getchar();continue;}else{if(sz==1)push_num(Num,num);sz=0;x=GetTop(Operate);switch(Precede(GetTop(Operate),c)){case '<':{push_operate(Operate,c);c=getchar();break;}case '=':{pop_operate(Operate,e);c=getchar();break;}case '>':{pop_num(Num,a);pop_operate(Operate,e);pop_num(Num,b);push_num(Num,caculate(b,e,a));break;}}}}pop_operate(Operate,e);if(e!='#')flat=0;if(flat==1){pop_num(Num,a);return a;}if(flat==0)return 0;}五．实验结果与讨论（描述最终得到的结果，并进行分析说明，可能的误差原因）第一题：1 把主函数中的ClearStack (S);DsetroyStack(S)注释掉的结果：2 不把ClearStack (S)注释掉，把栈清空：3 不把DsetroyStack(S)注释掉，即销毁栈：出现一堆乱码，说明销毁成功。

C语言程序设计上机实验报告（精选5篇）第一篇：C语言程序设计上机实验报告黔南民族师范学院 C语言程序设计上机实验报告系部：计算机科学系年级：2013 级班级：姓名：学号：实验时间：实验成绩：2013年月日实验三顺序结构程序的设计一实验名称：顺序结构程序的设计二．实验环境：windows XP系统，VC++6.0软件三．实验目的：四．实验内容：五．算法描述流程图六．源程序七．测试数据及运行结果八．实验心得实验成绩评分要求1、原创性发现抄袭或雷同成绩为0分2、正确性程序正确60分3、可读性格式清楚，有注释，变量命名规范20分4、健壮性对特殊测试数据有考虑有测试10分5、效率程序运行效率高10分第二篇：《c语言程序设计》上机实验报告要求《c语言程序设计》上机实验报告要求1.实验环境：软件系统：使用的软件环境硬件系统：机型说明2.实验目的：掌握如何编辑、编译、链接调试运行c程序3.实验内容：（1）掌握顺序结构程序设计.P26 ,p49,p62 3.2~3.7（2）掌握选择结构程序设计（if 和switch语句的用法）p4.2~（3）循环结构程序设计（while, dowhile,for语句的用法）。

（4）掌握数组的定义、输入和输出的方法，字符数组、字符串函数的使用。

（5）了解函数的定义，熟悉函数实参与形参的“值传递”方式，掌握函数的嵌套调用和递归调用方法。

（6）熟悉指针含义及其使用。

（7）熟悉结构体和共用体的使用。

（8）熟悉文件的使用。

4.实验要求：（1）输入编写的源程序，检查程序有无错误（语法和逻辑错误），有则改之。

（2）编译和连接，仔细分析编译信息，如有错误应找出原因并改正。

（3）运行程序，输入数据，分析结果。

5.实验结果：输出程序清单和运行结果。

（要求把原题内容，调试好的程序和其结果一并打印），6.实验体会分析运行结果，本次调试程序取得的经验（遇到的问题，解决的方法等）。

第三篇：C程序设计上机实验报告10C程序设计实验报告实验名称：指针与数组学时安排：2课时实验类别：上机操作型实验要求：1人1组￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣一、实验目的1.理解指针、地址和数组间的关系；2.掌握通过指针操作数组元素的方法；3.掌握数组名作为参数的编程方式。

第1篇一、实验目的本次实验旨在通过实际操作，加深对栈这一数据结构的理解，掌握栈的基本操作，包括初始化、入栈、出栈、取栈顶元素、判栈空等。

同时，通过实验练习，提高编程能力和问题解决能力。

二、实验内容1. 栈的定义及特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈的应用实例三、实验过程1. 栈的定义及特点栈是一种后进先出（LIFO）的数据结构，它只允许在一端进行插入和删除操作。

栈的顶元素总是最后被插入的元素，也是最先被删除的元素。

2. 栈的顺序存储结构顺序存储结构是使用数组来实现栈。

定义一个数组作为栈的存储空间，同时定义一个指针top来指示栈顶元素的位置。

3. 栈的链式存储结构链式存储结构是使用链表来实现栈。

定义一个节点结构体，其中包含数据和指向下一个节点的指针。

头节点作为栈顶元素。

4. 栈的基本操作（1）初始化：创建一个空栈，top指针指向栈底。

（2）入栈：将新元素插入到栈顶。

如果栈满，则进行扩容。

（3）出栈：删除栈顶元素，并将其返回。

如果栈空，则返回错误信息。

（4）取栈顶元素：返回栈顶元素的值，但不删除栈顶元素。

（5）判栈空：判断栈是否为空，如果为空，则返回true；否则，返回false。

5. 栈的应用实例（1）括号匹配检验：利用栈判断一个字符串中的括号是否匹配。

（2）算术表达式求值：利用栈实现算术表达式求值，包括四则运算和括号。

四、实验结果与分析1. 初始化栈初始化栈后，栈为空，top指针指向栈底。

2. 入栈操作将元素1、2、3依次入栈，栈的状态如下：```top -> 3 -> 2 -> 1```3. 出栈操作依次出栈元素，栈的状态如下：```top -> 2 -> 1```4. 取栈顶元素取栈顶元素2，栈的状态不变。

5. 判栈空当栈中只有一个元素时，判断栈为空，返回false。

6. 括号匹配检验对于字符串"((()))"，括号匹配检验结果为true；对于字符串"(()))"，括号匹配检验结果为false。

一、实验目的本次实验旨在使学生掌握栈的顺序存储结构，理解栈的基本操作，并能够通过编程实现栈的初始化、入栈、出栈、判空、取栈顶等基本功能。

同时，通过实验加深对数据结构中栈的应用理解，提高编程能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C/C++3. 开发环境：Visual Studio三、实验内容1. 栈的顺序存储结构- 实现栈的顺序存储结构，包括定义栈的存储空间和栈顶指针。

- 设计栈的初始化、判空、入栈、出栈、取栈顶等基本操作。

2. 栈的基本操作- 编写代码实现栈的初始化函数，初始化栈的空间和栈顶指针。

- 实现判空函数，检查栈是否为空。

- 实现入栈函数，将元素添加到栈顶。

- 实现出栈函数，从栈顶移除元素。

- 实现取栈顶函数，获取栈顶元素但不移除。

3. 栈的应用- 利用栈实现十进制数与二进制数的转换。

- 利用栈实现函数调用栈，模拟函数调用的过程。

四、实验步骤1. 定义栈的结构体```ctypedef struct {int array; // 动态分配的数组，用于存储栈元素 int top; // 栈顶指针int maxSize; // 栈的最大容量} SeqStack;```2. 实现栈的基本操作- 初始化栈```cvoid InitStack(SeqStack s, int maxSize) {s->array = (int )malloc(sizeof(int) maxSize); s->top = -1;s->maxSize = maxSize;}```- 判空```cint IsEmpty(SeqStack s) {return s->top == -1;}```- 入栈```cint Push(SeqStack s, int x) {if (s->top == s->maxSize - 1) { return 0; // 栈满}s->array[++s->top] = x;return 1;}```- 出栈```cint Pop(SeqStack s, int x) {if (IsEmpty(s)) {return 0; // 栈空}x = s->array[s->top--];return 1;}```- 取栈顶```cint GetTop(SeqStack s, int x) {if (IsEmpty(s)) {return 0; // 栈空}x = s->array[s->top];return 1;}```3. 实现十进制数与二进制数的转换- 编写函数实现十进制数转换为二进制数，利用栈存储转换过程中的余数。

顺序栈实验报告顺序栈实验报告一、引言顺序栈是一种基本的数据结构，它具有先进先出的特点。

在本次实验中，我们将学习并实现顺序栈的基本操作，包括入栈、出栈、判空和获取栈顶元素等。

通过这次实验，我们将深入理解栈的概念和原理，并掌握如何使用顺序栈解决实际问题。

二、实验目的1. 学习顺序栈的定义和基本操作。

2. 掌握顺序栈的实现方法。

3. 理解顺序栈的应用场景。

三、实验过程1. 定义顺序栈的结构在本次实验中，我们选择使用数组来实现顺序栈。

首先，我们需要定义一个栈的结构体，包括栈的容量和栈顶指针。

2. 初始化栈在实验开始时，我们需要初始化一个空栈。

这里，我们将栈顶指针设置为-1，表示栈为空。

3. 入栈操作当我们需要将一个元素压入栈时，我们首先判断栈是否已满。

如果栈已满，则无法进行入栈操作；否则，我们将栈顶指针加1，并将元素放入栈顶位置。

4. 出栈操作当我们需要从栈中弹出一个元素时，我们首先判断栈是否为空。

如果栈为空，则无法进行出栈操作；否则，我们将栈顶指针减1，并返回栈顶元素。

5. 判空操作判断栈是否为空可以通过检查栈顶指针是否等于-1来实现。

如果栈顶指针等于-1，则表示栈为空；否则，表示栈非空。

6. 获取栈顶元素要获取栈顶元素，我们只需返回栈顶指针所指向的元素即可。

需要注意的是，此操作不会改变栈的状态。

四、实验结果通过实验，我们成功实现了顺序栈的基本操作，并进行了测试。

在测试过程中，我们发现顺序栈可以有效地存储和操作数据。

我们可以轻松地将元素入栈和出栈，并通过判断栈是否为空来避免错误操作。

同时，获取栈顶元素的操作也非常方便，可以快速获取栈中最新的数据。

五、实验总结通过本次实验，我们深入了解了顺序栈的概念和原理，并掌握了顺序栈的基本操作。

顺序栈作为一种基本的数据结构，在实际应用中具有广泛的用途。

例如，在计算机程序中，我们可以使用顺序栈来实现函数调用的堆栈，以便保存函数的返回地址和局部变量等信息。

此外，在表达式求值、括号匹配和逆波兰表达式等问题中，顺序栈也发挥着重要的作用。

数据结构上机实验二-栈和链队列数据结构上机实验二实验内容:栈和链队列的基本操作实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对堆栈和队列的理解.实验要求:1) 栈和队列的显示要作为函数被调用.2) 把自己使用的栈和队列结构明确的表达出来.分组要求：可单独完成，也可两人一组。

评分标准：1) 只完成第一或第二题，3分；2）完成一和二题，得5分；3）在2）基础上，可选做三）中的题目。

题目:一)堆栈题（顺序栈）:创建一个栈+入栈+出栈(1)由键盘一个一个的输入正整数，建立相应的堆栈，输入-1时，堆栈结束；(2)在（1）中创建的堆栈中添加一个元素；(3)在（1）中创建的堆栈中删除一个元素；(要求在显示器可见)；二)链队列题目：初始化队列+入队列+出队列+销毁队列(1)初始化一个链队列；(2)在初始化好的链队列中放入数，入队列，完成后要求显示；(3)从队列中出队列，要求显示出来的元素和之后的队列；(4)销毁创建的队列，释放内存；三）应用题（1）编制程序，将输入的十进制数据M 转换为八进制数据M8，将其调试通过。

在此基础上修改程序，实现十进制数据M向任意进制（2-9进制）的转换。

（1分）（2）编制程序，从键盘接收一个字符串(长度最长设为100)，检测其中的括号()，[]，{}匹配情况，若有成对括号则在屏幕输出括号对及其所包含的字符内容。

（2分）（3）假设以Ｉ和Ｏ分别表示入栈和出栈操作。

栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由Ｉ和Ｏ组成的序列，称可以操作的序列为合法序列，否则为非法序列。

编写一个算法，判断所给的序列S1：ＩＯＯＩＩＯＩＯＯ，S２：ＩＯＯＩＯＩＩＯ及S３：ＩＩＩＯＩＯＩＯ，S４：ＩＩＩＯＯＩＯＯ是否合法。

（1分）（4）二项式(a+b)n展开后，其系数构成杨辉三角形，利用队列写出打印杨辉三角形的前n行的程序。

（1分）1111211331……（5）基于堆栈，编写迷宫求解程序。