数据结构实验三 顺序栈的实现
顺序栈的基本实现
顺序栈的基本实现
顺序栈是一种常见的数据结构，它遵循先进后出（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。
使用顺序栈时，需注意栈空间是否已满，以免造成溢出。
如果使用静态数组实现，需提前确定栈的最大容量；如果使用动态数组实现，可在入栈时判断容量是否已满，并在需要时进行自动扩容。
顺序栈的基本实现可以用于许多实际应用，例如表达式求值、递归函数调用、
迷宫路径搜索等。
它提供了一种便捷的数据结构，能够高效地进行元素的插入和删除操作。
总之，顺序栈是一种基本的数据结构，通过数组和栈顶指针的操作，实现了元
素的入栈和出栈。
它在计算机科学中有着广泛的应用，是学习和理解更复杂数据结构的重要基础。
数据结构实验三(顺序栈的基本操作)
printf(" 菜单列表 \n");
printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
printf("\t┃************************************************************┃\n");
fflush(stdin);
while(data!=0)
{
push(Sqstack,data);
printf("继续输入你要入栈的数据,若想结束,请按0终止\n");
scanf("%d",&data);
}
break;
}
case '3':
{
pop(Sqstack);
break;
}
case '4':
{
printf("输入取出的栈顶元素:\n");
InitStack(S);
printf("请输入一个十进制数和您将要转换的进制数(2,8,16):\n");
scanf("%d%d",&x,&y);
ile(x)
{
push(S,x%y);
x=x/y;
}
while(!Empty(S))
{
k[i]=pop(S);
i++;
m=i;
}
printf("十进制数转化为进制数为:");
printf("其值为:%d\n",GetTop(Sqstack));
数据结构实验报告 顺序栈
《数据结构与算法》实验报告一、实验内容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;}。
数据结构实验3：C++实现顺序栈类与链栈类
数据结构实验3：C++实现顺序栈类与链栈类实验33.1 实验⽬的熟练掌握栈的顺序存储结构和链式存储结构。
熟练掌握栈的有关算法设计，并在顺序栈和链栈上实现。
根据具体给定的需求，合理设计并实现相关结构和算法。
3.2实验要求3.2.1 顺序栈的实验要求顺序栈结构和运算定义，算法的实现以库⽂件⽅式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件⼯程要求；程序有适当的注释。
3.2.2 链栈实验要求本次实验中的链栈结构指带头结点的单链表；链栈结构和运算定义，算法的实现以库⽂件⽅式实现，不得在测试主程序中直接实现；实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件⼯程要求；程序有适当的注释。
3.3 实验任务3.3.1 顺序栈实验任务设计并实现⼀个顺序栈，编写算法实现下列问题的求解。
<1>利⽤顺序栈实现将10进制数转换为16进制数。
第⼀组数据：4 / 4第⼆组数据：11 / B第三组数据：254 / FE第四组数据：1357 / 54D<2>对⼀个合法的数学表达式来说，其中的各⼤⼩括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。
设计算法对以字符串形式读⼊的表达式S，判断其中的各括号是否是匹配的。
3.3.2 链栈实验任务以带头结点的单链表表⽰链栈，编写算法实现下列问题的求解。
<1>利⽤顺序栈实现将10进制数转换为16进制数。
第⼀组数据：4第⼆组数据：11第三组数据：254第四组数据：1357<2>对⼀个合法的数学表达式来说，其中的各⼤⼩括号“{”，“}”，“[”，“]”，“(”和“)”应是相互匹配的。
设计算法对以字符串形式读⼊的表达式S，判断其中的各括号是否是匹配的。
3.4 选做题⾮必做内容，有兴趣的同学选做。
⾃⾏选择栈的存储结构。
<1>假设栈的输⼊序列为1、2、3、...、n，设计算法实现对给定的⼀个序列，判定其是否是此栈合法的输出序列。
数据结构实验报告_栈(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。
数据结构实验三栈的实现
实验报告2.链式存储程序运行结果1.栈的顺序存储#include<iostream>using namespace std;typedef int Elemtype;struct stack{Elemtype *p;int top;int maxsize;};bool InitStack(stack &a)/*初始化栈*/{a.maxsize=10;a.p=new Elemtype[a.maxsize];if(!a.p){cout<<"分配空间失败"<<endl;return false;}a.top=-1;return true;}void PushStack(stack &a,Elemtype data)/*入栈*/{if(a.top==a.maxsize-1){a.p=(Elemtype*)realloc(a.p,2*a.maxsize* sizeof(Elemtype));a.maxsize=2*a.maxsize;}a.top++;a.p[a.top]=data;}bool PopStack(stack &a,Elemtype &data)/*出栈*/{if(a.top==-1){cout<<"栈为空"<<endl;return false;}data=a.p[a.top];a.top--;return true;}void DisplayStack(stack &a)/*显示栈中元素*/ {if(a.top==-1)cout<<"栈为空"<<endl;cout<<"栈顶位置为"<<a.top<<endl;cout<<"栈所占空间大"<<a.maxsize<<endl;cout<<"栈中数据为：";for(int i=0;i<a.top+1;i++)cout<<a.p[i]<<" ";cout<<endl;}bool EmptyStack(stack &a)/*判断栈是否为空*/ {return a.top==-1;}void main(){stack a;Elemtype data;InitStack(a);for(int i=0;i<10;i++)PushStack(a,i+2);DisplayStack(a);cout<<endl;cout<<"一、入栈"<<endl;cout<<"数据：";cin>>data;PushStack(a,data);DisplayStack(a);cout<<endl;cout<<"二、出栈"<<endl;if(PopStack(a,data))cout<<"栈顶"<<data<<"已出"<<endl;elsecout<<"出栈失败！！"<<endl;DisplayStack(a);cout<<endl;cout<<"三、该栈是否为空？"<<endl;if(EmptyStack(a))cout<<"是"<<endl;elsecout<<"否"<<endl;delete []a.p;}2.栈的链式存储#include<iostream>using namespace std;typedef int Elemtype;struct Slink{Elemtype data;Slink *next;};void InitSlink(Slink *&p)/*初始化栈*/{p=NULL;}bool EmptySlink(Slink *p)/*判断栈是否为空*/ {return p==NULL;}void PushSlink(Slink *&p,Elemtype item)/*入栈*/{Slink *q;q=new Slink;q->data=item;q->next=p;p=q;}bool PopSlink(Slink *&p,Elemtype &item)/*出栈*/{Slink *q;q=p;if(q==NULL){cout<<"栈为空！"<<endl;return false;}p=p->next;item=q->data;delete q;return true;}void DisplaySlink(Slink *p)/*显示栈中元素*/ {int i=0;if(p==NULL){cout<<"栈为空！"<<endl;exit(1);}cout<<"第一个数据为栈顶,值"<<p->data<<endl;while(p!=NULL){cout<<"第"<<i+1<<"个数据："<<p->data<<endl;p=p->next;i++;}cout<<"栈的长度为"<<i<<endl;}void ClearSlink(Slink *&p)/*清空栈的空间*/ {Slink *q;while(p!=NULL){q=p;p=p->next;delete q;}}void main(){Slink *head;Elemtype data;InitSlink(head);for(int i=0;i<10;i++)PushSlink(head,i+3);DisplaySlink(head);cout<<endl;cout<<"一、入栈"<<endl;cout<<"数据：";cin>>data;PushSlink(head,data);DisplaySlink(head);cout<<endl;cout<<"二、出栈"<<endl;if(PopSlink(head,data))cout<<"栈顶"<<data<<"已出"<<endl;elsecout<<"出栈失败！！"<<endl;DisplaySlink(head);cout<<endl;cout<<"三、该栈是否为空？"<<endl;if(EmptySlink(head))cout<<"是"<<endl;elsecout<<"否"<<endl;ClearSlink(head);}。
顺序栈的实现总结(推荐6篇)
顺序栈的实现总结第1篇栈是只允许在一端进行插入或删除的线性表。
注意栈是个操作受限的线性表栈顶：只允许插入或者删除栈底：固定的，不允许进行插入或删除的另一端空栈：不含任何数据元素的栈栈又被称为后进先出的线性表，简称为LIOF（last in first out）顺序栈的实现总结第2篇栈是只允许在一端进行插入或者删除操作的线性表。
如图所示栈顶(Top)。
线性表允许进行插入删除的那一端。
栈底(Bottom)。
固定的，不允许进行插入和删除的另一端。
空栈。
不含任何元素。
假设某个栈S=(a1,a2,a3,a4,a5),如上图所示，则a1为栈底元素,a5为栈顶元素。
由于栈只能在栈顶进行插入和删除操作，进栈次序依次是a1,a2,a3,a4,a5,而出栈次序为a5,a4,a3,a2 ,a1。
栈的操作特性为后进先出。
2.栈的基本操作InitStack(&S):初始化一个空栈S。
StackEmpty(S):判断一个栈是否为空,若为空则返回true，否则返回false。
Push(&S,x):进栈，若栈S未满,则将x加入使之成为新栈顶。
Pop(&S,x):出栈，若栈S非空，则弹出栈顶元素，并用x返回。
GetTop(S,&x):读取栈顶元素，若S非空，则用x返回栈顶元素。
DestroyStack(&S):销毁栈。
顺序栈的实现总结第3篇另外用stacksize表示栈可使用的最大容量简单、方便、但是容易溢出(数组大小固定)base == top是栈空的标志top - base == stacksize是栈满的标志。
具体栈空、栈满的示意图如下1.报错，返回系统2.分配更大的空间，作为栈的存储空间，将原栈的内容移入新栈上溢：栈已经满，又要压入元素下溢：栈已经空，还要弹出元素（注:上溢是一种错误，使问题的处理无法进行;而下溢一般认为是—种结束条件，即问题处理结束。
）bool InitStack(SqStack &S); //1.栈的初始化bool StackEmpty(SqStack S); //2.判断是否为空int StackLength(SqStack S); //3.求栈的长度void DestroyStack(SqStack &S); //4.销毁栈void ClearStack(SqStack &S); //5.清空顺序栈bool Push(SqStack &S, ElemType e); //6.入栈bool Pop(SqStack &S, ElemType &e); //7.出栈bool Gettop(SqStack &S, ElemType &e); //8.得到栈顶元素顺序栈的实现总结第4篇1.顺序栈的实现采用顺序存储的栈称为顺序栈，它利用一组连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针top指示前栈顶元素的位置。
数据结构实验报告三栈的实现
实验报告一、实验题目：栈的实现二、实验目的：掌握栈的特点。
熟悉在栈上进行的各种操作。
三、实验要求：1．建立一个接口，定义一些常用的基本方法；2．用类实现该接口的基本方法：入栈；出栈；取栈顶元素；判空、判满；3．定义客户类来调用接口中的方法；四、实验环境：一台PC机，Eclipse软件五、程序代码：a．栈的接口：package Stack;public interface StackInterface<T> {public void push(T newEntry);public T pop();public T peek();public boolean isEmpty();public void clear();}b．基于链表的实现的方法类package Stack;public class LinkedStack <T>implements StackInterface<T> ,java.io.Serializable{ private Node topNode; //引用链表中第一个结点public LinkedStack(){topNode=null;}public void push(T newEntry) { //将新元素插入栈顶// TODO Auto-generated method stubNode newNode =new Node(newEntry,topNode);topNode=newNode; //将新结点指向栈顶结点}public T pop() { //删除并返回栈顶// TODO Auto-generated method stubT top=null;if(topNode!=null){top=topNode.getData();topNode=topNode.getNextNode();}return top;}public T peek() { //取出栈顶并且不以任何方式改变栈// TODO Auto-generated method stubT top=null;if(topNode!=null)top=topNode.getData();return top;}public boolean isEmpty() { 检查栈是否为空// TODO Auto-generated method stubreturn topNode==null;}public void clear() { 从栈中删除所有元素// TODO Auto-generated method stubtopNode=null;}private class Node implements java.io.Serializable //构造私有类Node {private T data;private Node next;private Node(T dataPortion){data=dataPortion;next=null;}private Node(T dataPortion,Node nextNode){data=dataPortion;next=nextNode;}T getData(){return data;}void setData(T newData){data=newData;}Node getNextNode(){return next;}void setNextNode(Node nextNode){next=nextNode;}}}c.基于数组的实现的方法类package Stack;public class ArrayStack<T> implements StackInterface<T>{private T[] stack; //存放栈元素的数组private int topIndex; //栈顶元素索引private static final int DEFAULF_MAX_SIZE=50;public ArrayStack(){this(DEFAULF_MAX_SIZE);}public ArrayStack(int initialCapacity){stack=(T[]) new Object[initialCapacity];topIndex=-1;}public void push(T newEntry) { //将新元素插入栈顶// TODO Auto-generated method stubtopIndex++;if(topIndex>=stack.length) //若数组已满doubleArray(); //扩展数组stack[topIndex]=newEntry; //将新元素插入栈顶}private void doubleArray() //扩展数组{T[] oldList=stack;int oldSize=oldList.length;stack=(T[]) new Object[2*oldSize];for(int index=0;index<oldSize;index++)stack[index]=oldList[index];}public T pop() { //删除并返回栈顶// TODO Auto-generated method stubT top=null;if(!isEmpty()){top=stack[topIndex];stack[topIndex]=null;topIndex--;}return top;}public T peek() { //取出栈顶并且不以任何方式改变栈// TODO Auto-generated method stubT top=null;if(!isEmpty())top=stack[topIndex];return top;}public boolean isEmpty() { //检查栈是否为空// TODO Auto-generated method stubreturn topIndex<0;}public void clear() { 从栈中删除所有元素// TODO Auto-generated method stubfor(topIndex=stack.length;topIndex>0;topIndex--)pop();}}d．基于链表的实现类package Stack;public class ClientStack {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubStackInterface<String>myStack=new LinkedStack<String>(); myStack.push("Jim");myStack.push("Jess");myStack.push("Jill");myStack.push("Jane");myStack.push("Joe");String top=(String)myStack.peek();System.out.println(top+" is at the top of the stack.");top=(String)myStack.pop();System.out.println(top+" is removeed from the stack.");top=(String)myStack.peek();System.out.println(top+" is at the top of the stack.");top=(String)myStack.pop();System.out.println(top+" is removeed from the stack.");}}e.基于数组的实现类package Stack;public class ClientArrayStack {public static void main(String[] args) {StackInterface tryRunArray=new ArrayStack();tryRunArray.push("41");tryRunArray.push("42");tryRunArray.push("43");tryRunArray.push("44");tryRunArray.push("45");Object top = tryRunArray.peek();System.out.println(top+" is at the top of the stack.");top=tryRunArray.pop();System.out.println(top+" is removeed from the stack.");top = tryRunArray.peek();System.out.println(top+" is at the top of the stack.");top=tryRunArray.pop();System.out.println(top+" is removeed from the stack.");}}六、程序的调试与分析a．基于链表的实现类：b．基于数组的实现类：。
实验3顺序栈的基本操作
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");
③输出栈元素OutputStack(SqStack *S)
2)本程序包出栈函数含6个函数。
主函数main()
进栈函数PushStack()
出栈函数PopStack()
取栈顶元素GetStackTop()
显示栈元素OutputStack()
四：详细设计
1)类型定义
typedef struct SNode
{
int data;
struct SNode *next;
}SNode,*LinkStack;
LinkStack top;
2)基本操作
进栈操作
LinkStack PushStack(LinkStack top,int x) //进栈
{
LinkStack s;
s=(LinkStack)malloc(sizeof(SNode));
return top;
}
else printf("栈是空的，无法退栈！\n"); return 0;
}
取栈顶元素
int GetStackTop(LinkStack top) //取栈顶元素
{
return top->data;
实验三--顺序栈操作实现
实验日期： 2017 年 4 月 1 日实验目的及要求1. 熟练掌握栈的结构，以及这种数据结构的特点；2. 能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法。
实验内容已知顺序栈的类型定义如下：#define MAX 100typedef char datatype;typedef struct{datatype data[MAX];int top;}SeqStack, *SeqStackptr;任务1．题目要求任务一：创建自定义头文件，包含顺序栈的数据类型定义及基本操作函数，需定义的基本操作如下：（1）void Error(char *s);/*自定义错误处理函数*/（2）void InitStack (SeqStackptr sp);/*初始化栈——置空栈*/（3）int EmptyStack (SeqStackptr sp);/*判栈空*/（4）int FullStack (SeqStackptr sp);/*判栈满*/（5）void Push (SeqStackptr sp, datatype x);/*进栈(元素压入栈顶)*/（6）datatype Pop (SeqStackptr sp);/*出栈(元素从栈顶弹出)*/（7）datatype GetTop (SeqStackptr sp);/*读栈顶元素(不出栈)*/（8）int Count (SeqStackptr sp);/*计算栈中元素个数*/任务二：创建一个新的程序文件，请调用提供的顺序栈操作的函数完成把源文本文件中的所有十进制数转换成相应的指定进制的数值存于新的文本文件中，要求定义如下函数：（1）void Trans(int n, int r, char str[])功能：把n整数转换为r进制的值并存于str数组中；（2）void TransFile(int r,char strin[],char strout[]);功能：把strin文件中十进制整数转换为r进制的值并存于文件strout 中。
栈的顺序存储实验报告(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. 栈的销毁当栈不再需要时，释放栈所占用的内存空间。
实验结果表明，顺序栈的基本操作能够正常进行，验证了顺序栈的正确性。
顺序栈的实现实验报告
数据结构实验报告三-顺序栈的实现一、实验环境：Windows 10 64位MinGW GCC 4.8.1IDEA：CLoin二、实验内容：编写程序实现一个顺序栈，并利用栈实现将十进制转换成十六进制。
三、算法流程：输入一个十进制数，利用短除法和栈先进先出的特性实现进制的转换。
四、程序代码：#include<stdlib.h>#include<stdio.h>#define MAXSIZE 100#define N 16typedef struct stack{int data[MAXSIZE];int top;}Stack;void initstack(Stack *s){s->top=0;}int stackempty(Stack *s){if(s->top==0)return 1;elsereturn 0;}void push(Stack *s,int i){if(s->top<=MAXSIZE){s->data[s->top]=i;s->top++;}elseprintf("空间不足\n");}int pop(Stack *s){int e;if(!stackempty(s)){s->top--;e=s->data[s->top];return e;}elseprintf("空\n");}void conversion(int num){Stack s;int e;initstack(&s);while(num){push(&s,num%16);num=num/16;}while(!stackempty(&s)){e=pop(&s);if(e==10)printf("A");else if(e==11)printf("B");else if(e==12)printf("C");else if(e==13)printf("D");else if(e==14)printf("E");else if(e==15)printf("F");elseprintf("%d",e);}}int main(){int num;printf("Input a num:\n");scanf("%d",&num);printf("the num converted:\n");conversion(num);return 0;}五、运行截图。
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
/*判队空*/
int QueueEmpty(SeqQueue *sq)
{
if(sq->rear==sq->front)
return 1;
else
return 0;
}
/*循环队列入队*/
void InQueue(SeqQueue *sq,ElemType x)
{
if ((sq->rear+1)%MaxSize==sq->front) /*队满*/
InitStack(s);
printf("(2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf("(3)输入要进栈的数据个数：");
scanf("%d",&n);
printf("依次输入进栈的%d个整数：",n);
/*数据依次进栈*/
for(i=0; i<n; i++)
{
printf("循环队列已空，不能进行出队操作！\n");
exit(1);
}
else{
x=sq->data[sq->front];
sq->front=(sq->front+1)%MaxSize;
return x;
}
}
/*取队头元素*/
ElemType GetQueue(SeqQueue *sq)
{
void InitQueue(SeqQueue *sq); /*初始化队列*/
int QueueEmpty(SeqQueue *sq); /*判队空*/
数据结构实验三 顺序栈的实现
实验三顺序栈的实现实验类型：验证性实验学时：2学时一、实验目的：掌握顺序栈的基本操作，如进栈、出栈、判断栈空和栈满，取栈顶元素等运算在顺序存储结构上的运算；并能够运用栈的基本操作解决问题，实现相应算法。
二、实验要求：1、完成顺序栈的基本操作算法并上机调试通过。
2、撰写实验报告，提供实验结果和数据。
三、实验内容:设计你的栈的顺序存储结构体，编程实现栈的基本操作。
栈中的数据元素类型最好为字符类型，方便今后对字符串的算法设计和应用。
测试数据示例：(1) 以“ABCDEFG”的字符串顺序进栈；(2) 以合适顺序出栈得到序列“CDBAGFE”；(3) 取栈顶元素得到‘F’；(4) 进栈直到栈满和出栈直到栈空，检验对这两种情形的正确判断和处理。
[实验要点及说明]：借助实验一线性表的顺序存储程序进行改进栈(stack)：是限定仅在表尾进行插入或删除操作的线性表。
栈顶(Top)：允许插入和删除的一端，为变化的一端。
栈底(Bottom):栈中固定的一端。
空栈：栈中无任何元素。
特点：根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
也就是说，栈是一种后进先出(Last In First Out)的线性表，简称为LIFO表。
参考：顺序栈的数据类型C语言描述：#define stacksize 100 //定义栈的最大容量typedef char elemtype;typedef Struct{elemtype data[stacksize]; //将栈中元素定义为elemtype类型int top; //:指向栈顶位置的指针}sqstack;栈的运算：1.初始化栈：InitStack将栈S置为一个空栈(不含任何元素)。
2.进栈：Push将元素X插入到栈S中，也称为“入栈”、“插入”、“压入”。
3.出栈：Pop删除栈S中的栈顶元素，也称为”退栈”、“删除”、“弹出”。
栈和队列实验报告
数据结构实验报告顺序栈的实现和基本操作一、需求分析（1）顺序栈◆栈的典型操作是入栈和出栈，前者将新元素压入栈中，后者弹出栈顶元素。
栈只提供对栈顶元素的访问操作，由top ( )完成。
Push ( )和Pop ( )还有Top ( )共同构成了栈的最小功能接口。
此外，为了方便使用，栈还有判空，判满和输出栈等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序栈的初始化后显示初始化成功，在判断栈是否为空时显示当前栈为空，入栈后显示入栈成功或者栈已满。
出栈时显示出栈元素或者栈为空。
输出栈时依次显示栈中元素。
◆程序功能：初始化栈，判断栈是否为空，判断栈是否为满，入栈，出栈，取栈顶元素，出栈同时返回栈顶元素和输出栈等功能。
◆测试数据：初始化后输入栈的长度为4。
判断栈是否为空。
进行5次入栈操作。
分别输入1 2 3 4 5输出栈。
执行2次出栈操作。
输出栈。
查看栈顶元素。
输出栈。
（2）队列◆队列的典型操作是入队和出队，前者将新元素压入队列中，后者弹出队首头元素。
队列只提供对队头元素和队尾元素的操作，由DeQueue ( ) 和EnQueue( )完成。
DeQueue还有EnQueue ( )共同构成了队列的最小功能接口。
此外，为了方便使用，队列还有判空，判满和输出队列等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序队列的初始化后显示初始化成功，在判断队列是否为空时显示当前队列为空，入队列后显示入队成功或者队列已满。
出队列时显示出队首元素或者队列为空。
输出队列时依次显示队列中元素。
◆程序功能：初始化队列，判断队列是否为空，判断队列是否为满，入队，出队，取队首元素，输出队列等功能。
◆测试数据：初始化后输入队列的长度为54。
判断队列是否为空。
进行5次入队操作。
分别输入1 2 3 4 5输出队列。
执行2次出队操作。
输出队列。
查看队首元素。
输出队列。
二、概要设计（1）顺序栈◆为了实现程序的功能，在.H文件中定义了栈的模板类. template <class T>class Stack{私有数据成员：private:栈的最大长度int MaxSize;栈顶位置int top;顺序栈首地址T *theArray;公有成员：public:栈的初始化void InitStack(int capacity=10);操作结果：初始化一个默认长度为10的空栈判断栈是否为空bool IsEmpty() const;初始条件：栈已存在。
顺序栈基本操作实验报告【精选文档】
数据结构实验三课程数据结构实验名称顺序栈基本操作第页专业班级学号姓名实验日期：年月日评分一、实验目的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。
数据结构实验：顺序栈的实现
实验目的
• 掌握栈的特点。 • 熟悉在栈上进行的各种操作。
实验要求
• 编写C（C＋＋）应用程序，实现栈上的 各种操作：初始化，销毁，入栈，出栈， 取栈顶元素，求栈的长度、“判空”。
• 编写一个程序来测试以上的操作。
实验报告的书写要求
• 实验目的 • 实验要求 • 实验环境 • 程序代码 • 程序的首先建立project • 然后创建一个头文件×××.h，其中有你的程
序中要用的数据类型，以及实现各种操作的函 数的声明（不包括函数体）。 • 再创建一个×××.cpp，其中有各个函数的函 数体（具体实现）。 • 最后创建主函数（程序入口） ×××.cpp ，其 中有用于输入、输出的语句，和一些必要的测 试数据。它来调用上述的函数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三顺序栈的实现
实验类型：验证性实验学时：2学时
一、实验目的：
掌握顺序栈的基本操作，如进栈、出栈、判断栈空和栈满，取栈顶元素等运算在顺序存储结构上的运算；并能够运用栈的基本操作解决问题，实现相应算法。
二、实验要求：
1、完成顺序栈的基本操作算法并上机调试通过。
2、撰写实验报告，提供实验结果和数据。
三、实验内容:
设计你的栈的顺序存储结构体，编程实现栈的基本操作。
栈中的数据元素类型最好为字符类型，方便今后对字符串的算法设计和应用。
测试数据示例：
(1) 以“ABCDEFG”的字符串顺序进栈；
(2) 以合适顺序出栈得到序列“CDBAGFE”；
(3) 取栈顶元素得到‘F’；
(4) 进栈直到栈满和出栈直到栈空，检验对这两种情形的正确判断和处理。
[实验要点及说明]：借助实验一线性表的顺序存储程序进行改进
栈(stack)：是限定仅在表尾进行插入或删除操作的线性表。
栈顶(Top)：允许插入和删除的一端，为变化的一端。
栈底(Bottom):栈中固定的一端。
空栈：栈中无任何元素。
特点：根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
也就是说，栈是一种后进先出(Last In First Out)的线性表，简称为LIFO表。
参考：顺序栈的数据类型C语言描述：
#define stacksize 100 //定义栈的最大容量
typedef char elemtype;
typedef Struct{
elemtype data[stacksize]; //将栈中元素定义为elemtype类型
int top; //:指向栈顶位置的指针
}sqstack;
栈的运算：
1.初始化栈：InitStack将栈S置为一个空栈(不含任何元素)。
2.进栈：Push将元素X插入到栈S中，也称为“入栈”、“插入”、“压入”。
3.出栈：Pop删除栈S中的栈顶元素，也称为”退栈”、“删除”、“弹出”。
4.取栈顶元素：GetTop 取栈S中栈顶元素。
5.判栈空：StackEmpty判断栈S是否为空，若为空，返回值为1，否则返回值为0。