数据结构实验——栈(附程序)
数据结构 栈实验 问题与答案
栈实验理学院信息与计算科学班级:学号:姓名:一、目的1、掌握栈的各种基本操作。
2、掌握基本操作在具体应用中的运用。
3、掌握程序设计的各种调试手段。
二、实验内容从键盘中接收字符,如果该字符与栈顶元素相同,则弹出栈顶元素,否者压入栈。
如果接收的字符为‘$’则停止输入。
要求先建立一个空栈。
三、实验课时2学时四、程序(包括源代码,输入,输出结果)#include<stdio.h>#include<stdlib.h>#define Stack_Size 10typedef struct{char elem[Stack_Size];int top;}SeqStack;void InitStack(SeqStack *S){S->top=-1;}int isEmpty(SeqStack *S){if(S->top==-1)return(1);elsereturn(0);}int push(SeqStack *S,char x){if(S->top==Stack_Size-1) return(0);S->top++;S->elem[S->top]=x;return(1);}int pop(SeqStack *S,char *x){if(S->top==-1) return(0);*x=S->elem[S->top];S->top--;return(1);}char GetTop(SeqStack *S){char x;if(S->top==-1) return(0);else{x=S->elem[S->top];return(x);}}int main(){SeqStack S;InitStack(&S);char a;char b;int flag=1;int tf;while(flag){a=getchar();if(a!='$'){if(a==GetTop(&S)&&!isEmpty(&S)){tf=pop(&S,&b);printf("%c出栈",b);}else{tf=push(&S,a);printf("%c入栈",a);}}else{flag=0;}}return(1);}运行结果:。
实验2栈实验报告
实验2 栈实验报告1. 实验目的通过本次实验,使学生了解栈的基本概念和应用,掌握栈的操作算法,培养学生的编程能力和算法思维。
2. 实验环境•编程语言:C/C++•开发工具:Visual Studio/Code/GCC•操作系统:Windows/Linux/macOS3. 实验内容本次实验主要包括以下几个方面的内容:1.实现一个简单的栈数据结构;2.实现栈的常见操作(如入栈、出栈、判空、长度等);3.利用栈解决括号匹配问题;4.利用栈实现逆波兰表达式求值;5.分析栈在函数调用中的应用。
4. 实验步骤4.1 栈的定义与实现首先,我们需要定义一个栈的数据结构。
在C/C++中,可以使用数组或链表来实现栈。
这里我们使用数组来实现。
#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;接下来,我们需要实现栈的常见操作。
入栈(push)void push(Stack* s, int value) {if (s->top >= MAX_SIZE - 1) {printf("栈已满,无法入栈\n");return;s->data[++s->top] = value;出栈(pop)int pop(Stack* s) {if (s->top < 0) {printf("栈已空,无法出栈\n");return -1;return s->data[s->top--];判空(isEmpty)int isEmpty(Stack* s) {return s->top < 0;获取栈长度(length)int length(Stack* s) {return s->top + 1;4.2 括号匹配问题括号匹配问题是栈的一个经典应用。
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");
数据结构实验报告之栈和队列
数据结构实验报告之栈和队列1. 编写程序实现顺序栈的各种基本运算:初始化、销毁、清空、判断是否为空栈、求栈的长度、取栈顶元素、进栈、出栈。
在此基础上设计⼀个主程序完成如下功能:(1)初始化栈s;(2)判断栈s是否为空;(3)依次进栈元素a,b,c,d;(4)判断栈s是否为空;(5)输出栈s的长度;(6)栈⾥元素依次出栈,并输出;(7)销毁栈s。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct {SElemType *base; //栈底指针SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间} SqStack;Status InitStack(SqStack &S) { //构造⼀个空栈SS.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 StackLength(SqStack S) {return S.top - S.base;}//StackLengthStatus DestoryStack(SqStack &S) {S.top = S.base;free(S.base);//若base的值为NULL,则表明栈结构不存在S.base = NULL;S.top = NULL;S.stacksize = 0;return OK;}Status StackEmpty(SqStack S) {if (S.top == S.base)return1;elsereturn0;}//StackEmptyStatus GetTop(SqStack S, SElemType &e) {if (S.top == S.base) return ERROR;e = *(S.top - 1);return OK;}//GetTopStatus 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.base == S.top)return ERROR;e = *(S.top - 1);S.top--;return OK;}//Popvoid main(){SqStack s;SElemType e;printf("(1)初始化栈\n");InitStack(s);printf("(2)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(3)依次进栈元素a,b,c,d\n");Push(s, 'a');Push(s, 'b');Push(s, 'c');Push(s, 'd');printf("(4)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(5)The length of the stack is %d\n", StackLength(s));printf("(6)The stack is ");while (!StackEmpty(s)){Pop(s, e);printf("%c \n", e);}printf("(7)销毁栈s");DestoryStack(s);}运⾏结果:2. 编写程序实现链队列的各种基本运算:初始化、销毁、清空、判断是否为空队列、求队列的长度、取队列的头元素、⼊队、出队。
栈队列实验报告代码
一、实验目的1. 理解栈和队列的基本概念及其特点。
2. 掌握栈和队列的顺序存储和链式存储实现方法。
3. 熟悉栈和队列的基本操作,如入栈、出栈、入队、出队等。
4. 通过编程实践,加深对数据结构理论知识的理解。
二、实验环境1. 编程语言:Python2. 开发环境:PyCharm三、实验内容本实验主要实现栈和队列的顺序存储和链式存储,并完成以下基本操作:1. 栈的顺序存储和链式存储实现2. 队列的顺序存储和链式存储实现3. 栈的基本操作:入栈、出栈、判断栈空、获取栈顶元素4. 队列的基本操作:入队、出队、判断队空、获取队首元素四、实验代码```python# 栈的顺序存储实现class Stack:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def push(self, item):self.items.append(item)def pop(self):if not self.is_empty():return self.items.pop() return Nonedef peek(self):if not self.is_empty():return self.items[-1] return None# 栈的链式存储实现class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedListStack:def __init__(self):self.head = Nonedef is_empty(self):return self.head is Nonedef push(self, data):new_node = Node(data)new_node.next = self.head self.head = new_nodedef pop(self):if not self.is_empty():data = self.head.dataself.head = self.head.next return datareturn Nonedef peek(self):if not self.is_empty():return self.head.datareturn None# 队列的顺序存储实现class Queue:def __init__(self):self.items = []def is_empty(self):return len(self.items) == 0def enqueue(self, item):self.items.append(item)def dequeue(self):if not self.is_empty():return self.items.pop(0) return Nonedef peek(self):if not self.is_empty():return self.items[0]return None# 队列的链式存储实现class NodeQueue:def __init__(self):self.head = Noneself.tail = Nonedef is_empty(self):return self.head is Nonedef enqueue(self, data):new_node = Node(data)if self.tail is None:self.head = self.tail = new_node else:self.tail.next = new_nodeself.tail = new_nodedef dequeue(self):if not self.is_empty():data = self.head.dataself.head = self.head.nextif self.head is None:self.tail = Nonereturn datareturn Nonedef peek(self):if not self.is_empty():return self.head.datareturn None# 测试代码if __name__ == "__main__":stack = Stack()stack.push(1)stack.push(2)stack.push(3)print("栈的顺序存储:", stack.items)print("栈顶元素:", stack.peek())print("出栈元素:", stack.pop())print("栈的顺序存储:", stack.items)linked_stack = LinkedListStack()linked_stack.push(1)linked_stack.push(2)linked_stack.push(3)print("栈的链式存储:", [node.data for node in linked_stack.head]) print("栈顶元素:", linked_stack.peek())print("出栈元素:", linked_stack.pop())print("栈的链式存储:", [node.data for node in linked_stack.head]) queue = Queue()queue.enqueue(1)queue.enqueue(2)queue.enqueue(3)print("队列的顺序存储:", queue.items)print("队首元素:", queue.peek())print("出队元素:", queue.dequeue())print("队列的顺序存储:", queue.items)linked_queue = NodeQueue()linked_queue.enqueue(1)linked_queue.enqueue(2)linked_queue.enqueue(3)print("队列的链式存储:", [node.data for node in linked_queue.head]) print("队首元素:", linked_queue.peek())print("出队元素:", linked_queue.dequeue())print("队列的链式存储:", [node.data for node in linked_queue.head]) ```五、实验总结通过本次实验,我们实现了栈和队列的顺序存储和链式存储,并完成了基本操作。
数据结构实验报告栈操作
《数据结构》实验报告◎实验题目: 栈的应用。
◎实验目的:熟悉掌握对栈的应用和基本操作。
◎实验内容:用算符优先法对算术表达式求值。
一、需求分析通过程序设计实现算符优先法:1 以字符串的形式输入整形数据和运算符号;2、输出算术表达式的结果;3、实现简单的一位整型数据的算术运算;4、测试数据:算术表达式,其中的整型数据均只有一位。
二概要设计1.基本操作void InitStack(SqStack *s)操作结果:栈的初始化。
int GetTop(SqStack *s)初始条件:栈已存在且不空;操作结果:将栈顶元素返回。
void Push(SqStack *s,int e)初始条件:栈已存在;操作结果:插入e作为新的栈顶元素。
char Pop1(SqStack *s)初始条件:运算符栈已存在且不空;操作结果:栈顶元素出栈。
int Pop2(SqStack *s)初始条件:运算数栈已存在且不空;操作结果:栈顶元素出栈。
char precede(char A, char B)操作结果:比较两个算符的优先级,并将比较结果返回。
int In(char Test)操作结果:判断字符是否是运算符。
int EvaluateExpression()操作结果:通过调用一系列的函数,对表达式求值。
main()操作结果:主要通过调用函数EvaluateExpression得到最终结果。
2.本程序包含两个模块:(1)构造栈的模块;(2)主程序模块;(三) 详细设计1.声明,栈的结构体和判断运算符优先级的表格(以数组形式表达):typedef struct{int *base;int *top;int stacksize;}SqStack;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define overflow 1#define error 0char OPSET[7]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};//运算符种类unsigned char Prior[7][7] ={ // 算符间的优先关系'>','>','<','<','<','>','>','>','>','<','<','<','>','>','>','>','>','>','<','>','>','>','>','>','>','<','>','>','<','<','<','<','<','=',' ','>','>','>','>',' ','>','>','<','<','<','<','<',' ','='};2.各个函数的详细设计:void InitStack(SqStack *s)//栈的初始化{s->base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));if(!s->base) exit(error); //存储分配失败s->top=s->base;s->stacksize=STACK_INIT_SIZE;}int GetTop(SqStack *s)//若运算符栈不空则用e返回栈顶元素{if(s->top==s->base)exit (overflow);return (*(s->top-1));}void Push(SqStack *s,int e)//插入e为新的栈顶元素{if(s->top-s->base>=s->stacksize){s->base=(int *)realloc(s->base,(STACK_INIT_SIZE+STACKINCREMENT)*sizeof(int));if(!s->base)exit(error);s->top=s->base+s->stacksize;;s->stacksize=s->stacksize+STACKINCREMENT;}*s->top=e;s->top++;}char Pop1(SqStack *s)//运算符栈顶元素出栈{if(s->top==s->base)return error;return (*--s->top);}int Pop2(SqStack *s)//运算数栈顶元素出栈{if(s->top==s->base)return error;return (*--s->top);}char Precede(char A, char B) //实现两个算符优先级的比较{return Prior[FindOpOrd(A,OPSET)][FindOpOrd(B,OPSET)];}在Precede函数中再调用FindOpOrd函数,设计如下:int FindOpOrd(char op,char *TestOp) //在Prior数组中按行或者按列找到算符对应的位置{int i;for(i=0; i< 7; i++){if (op == TestOp[i])return i;}}int Operate(int a,unsigned char theta, int b) //根据运算符进行二元运算{switch(theta){case '+': return a+b;case '-': return a-b;case '*': return a*b;case '/': if(b!=0)return a/b;elseexit(error);default : return error;}}int In(char Test) //判断字符是否为运算符,如果是运算符返回1,否则返回0{if('0'<=Test&&Test<='9')return 0;elsereturn 1;}i nt EvaluateExpression()//算符优先法的实现{SqStack OPTR,OPND;char c,theta;int a,b,result;InitStack (&OPTR); //创建运算符栈Push (&OPTR, '#'); //在运算符栈栈底放上#InitStack (&OPND); //创建运算数栈c =getchar();while (c!= '#'||GetTop(&OPTR)!='#'){if (In(c)==0) // 不是运算符则进栈{Push(&OPND,c-48);printf("运算数%d直接进运算数栈\n",c-48);c=getchar();}else{switch (Precede(GetTop(&OPTR), c)){case '<': // 栈顶元素优先级低Push(&OPTR, c);printf("运算符%c直接进运算符栈\n",c);c=getchar();break;case '=': // 脱括号并接收下一字符Pop1(&OPTR);printf("输入)后运算符栈进行脱括号操作\n");c=getchar();break;case '>': // 退栈并将运算结果入栈theta=Pop1(&OPTR);printf("运算符%c从运算符栈顶弹出\n",theta);b=Pop2(&OPND);printf("运算数%d从运算数栈顶弹出\n",b);a=Pop2(&OPND);printf("运算数%d从运算数栈顶弹出\n",a);Push(&OPND, Operate(a, theta, b));printf("运算数%d和运算数%d进行%c运算并将结果进运算数栈\n",a,b,theta);break;} // switch}} // whilereturn (Pop2(&OPND));} // EvaluateExpression函数EvaluateExpressio n通过调用其它函数实现了算符优先法计算表达式,因此主函数主要通过调用该函数进行运算。
数据结构 栈的实验报告
s.base=(int*)malloc(MAXNUM* sizeof(int));
if(!s.base) return 0;
s.top=s.base;
s.stacksize=MAXNUM;
return 1;
}
int push(stack &s,int x)
{
if(s.top-s.base>=s.stacksize)
技术原理:利用栈的基本操作来从事操作
实验步骤:#include<stdio.h>
#include<malloc.h>
#define MAXNUM 10
typedef struct
{
int *base;
int *top;
int stacksize;
}stack;
int Initstack(stack &s)
push(t,i);
for(i=1;i<=4;i++)
printf("%5d",pop(t));
printf("\n");
}
实
验
心
得ቤተ መጻሕፍቲ ባይዱ
利用实验来,来加强自己对战的理解,这样才能的理解。栈是一个很好的工具,为后面的数据结构的学习很重要。
教师评阅意见
教师签字
签字日期
年月日
数学与计算机科学系实验报告
课程:数据结构地点:实验室时间:年月日
学生姓名
王磊
班级
计本二班
学号
090312228
成绩
组别
同组姓名
仪器编号
实验项目
栈的实验
指导教师
数据结构实验报告栈
数据结构实验报告:栈摘要:本实验报告旨在介绍栈这一重要的数据结构,以及在实际应用中的使用。
栈是一种先进后出(LIFO)的数据结构,在计算机科学中有着广泛的应用。
本报告将详细介绍栈的定义、基本操作以及应用实例,并根据实验结果进行分析和总结。
1. 引言栈是一种基于线性表的数据结构,具有后进先出(LIFO)的特性。
它可以通过两个基本操作来实现:push(入栈)将元素添加到栈顶,pop(出栈)将栈顶元素移除。
栈在计算机科学中被广泛应用,如函数调用、表达式求值、括号匹配等。
2. 栈的实现栈可以通过数组或链表来实现。
数组实现的栈称为顺序栈,链表实现的栈称为链式栈。
无论是哪种实现方式,都需要实现以下基本操作:- push(element): 将元素添加到栈顶。
- pop(): 移除栈顶元素并返回。
- top(): 返回栈顶元素的值。
- isEmpty(): 判断栈是否为空。
- isFull(): 判断栈是否已满(仅顺序栈需要实现)。
3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。
每当一个函数被调用时,当前函数的局部变量、返回地址等信息都会被压入栈中。
当函数执行完毕时,这些信息会从栈中弹出,继续执行上一级函数。
3.2 表达式求值栈常用于表达式求值,特别是中缀表达式的转换和计算。
通过将中缀表达式转换为后缀表达式,可以方便地进行计算。
栈可以临时存储运算符,并根据运算符的优先级进行弹出和计算。
3.3 括号匹配栈的一个重要应用是括号匹配。
通过遍历字符串,将左括号压入栈中。
每当遇到右括号时,如果栈顶元素是匹配的左括号,则弹出栈顶元素;否则,表示括号不匹配。
4. 实验结果与分析根据我们对栈的实现和应用进行的实验,以下是我们得到的结论:- 通过数组实现的顺序栈在空间上存在一定的限制,可能会出现栈溢出的情况。
- 通过链表实现的链式栈没有空间限制,可以动态地添加和删除元素。
- 栈在函数调用和表达式求值中展现出了高效的性能,并能够简化程序的设计。
栈的操作(实验报告)
引言:栈是一种常见的数据结构,它具有特殊的操作规则,即先进后出(LIFO)。
本文将介绍栈的操作,并结合实验报告的方式详细阐述栈的概念、基本操作以及应用场景。
概述:栈是一种线性数据结构,由相同类型的元素按照特定顺序排列而成。
在栈中,只能在栈顶进行插入和删除操作,其他位置的元素无法直接访问。
栈具有两个基本操作:压栈(push)和弹栈(pop)。
其中,压栈将一个元素添加到栈顶,弹栈则是删除栈顶的元素。
除了基本操作外,栈还具有其他常见的操作,如获取栈顶元素(top)、判断栈是否为空(empty)等。
正文内容:一、栈的基本操作1.压栈(push)push操作的实现原理和步骤在实际应用中的使用场景和例子2.弹栈(pop)pop操作的实现原理和步骤在实际应用中的使用场景和例子3.获取栈顶元素(top)top操作的实现原理和步骤在实际应用中的使用场景和例子4.判断栈是否为空(empty)empty操作的实现原理和步骤在实际应用中的使用场景和例子5.栈的大小(size)size操作的实现原理和步骤在实际应用中的使用场景和例子二、栈的应用场景1.括号匹配使用栈实现括号匹配的原理和过程在编译器、计算表达式等领域中的应用2.浏览器的后退和前进功能使用栈来记录浏览器访问历史的原理和过程实现浏览器的后退和前进功能3.函数调用和递归使用栈来实现函数调用和递归的原理和过程在程序执行过程中的应用和注意事项4.实现浏览器缓存使用栈来实现浏览器缓存的原理和过程提高用户浏览速度的实际应用案例5.撤销操作使用栈来实现撤销操作的原理和过程在编辑器、图形处理软件等领域的实际应用总结:本文详细介绍了栈的操作,包括基本操作(压栈、弹栈、获取栈顶元素、判断栈是否为空、栈的大小)和应用场景(括号匹配、浏览器的后退和前进功能、函数调用和递归、实现浏览器缓存、撤销操作)。
通过了解栈的操作和应用,我们可以更好地理解数据结构中的栈,并能够在实际问题中灵活运用栈的特性。
栈的应用----数据结构实验(完整代码+注释+截图)
实验三栈的基本应用实验目的:熟练掌握顺序栈的基本操作(入栈、出栈等)实验内容:利用顺序栈实现一个十进制数转换为十六进制数实验要求:以栈的顺序存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果。
实验算法描述:初始化函数:InitStack(SqStack *s)销毁栈:Destroy(SqStack *s)栈置空:MakeEmpty(SqStack *s)判断栈是否空:IsEmpty(SqStack *s)求栈长:Getlength(SqStack *s)读取栈顶元素:Gettop(SqStack *s)入栈:Push(SqStack *s,int e)出栈:Pop(SqStack *s)访问栈内所有元素:Visit(SqStack *s)实验程序描述:#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include <iostream.h>typedef int selemtype;int ok=0;#define STACK_INIT_SIZE 20#define STACKINCREMENT 10typedef struct {selemtype *base;selemtype *top;int stacksize;int length;}SqStack;void InitStack(SqStack *s){if (ok==1)cout<<" 线性表以前已创建!"<<endl;else{s->base = (selemtype *) malloc (STACK_INIT_SIZE *sizeof(selemtype));if(!s->base) exit(4);s->top=s->base;s->stacksize = STACK_INIT_SIZE;s->length=0;ok=1;cout<<" 空栈已经建立!"<<endl<<endl;}}void Destroy(SqStack *s){free(s->base);s->base=s->top=NULL;s->stacksize=0;s->length=0;cout<<" 空栈已经销毁!"<<endl;ok=0;}void MakeEmpty(SqStack *s){if (s->top!=s->base){s->base = (selemtype *) realloc (s->base,STACK_INIT_SIZE *sizeof(selemtype));s->top=s->base;s->length=0;s->stacksize = STACK_INIT_SIZE;}cout<<" 栈已经为空!"<<endl<<endl;}void IsEmpty(SqStack *s){if (s->base==s->top)cout<<" 栈为空!"<<endl;else cout<<" 栈不是空的!"<<endl<<endl;}void Getlength(SqStack *s){cout<<" 栈的元素个数为:"<<s->length<<endl;}void Gettop(SqStack *s){int e=0;if (s->base == s->top)cout<<" 空栈!"<<endl;elsecout<<" 栈顶元素为:"<<*(s->top-1)<<endl;}void Push(SqStack *s,int e){if(s->top - s->base>=s->stacksize){s->base = (selemtype *) realloc (s->base,STACKINCREMENT *sizeof(selemtype));if(!s->base) exit (2);s->top=s->base + s->stacksize;s->stacksize +=STACKINCREMENT;}*s->top++ = e;++(s->length);cout<<" 插入完成,当前栈顶元素是--- "<<e<<endl<<endl;}void Pop(SqStack *s){int e;if(s->top==s->base)cout<<" 栈是空的!"<<endl;else{e= * --s->top;cout<<" 栈顶元素"<<e<<"已经删除!"<<endl<<endl;--(s->length);}}void Visit(SqStack *s){int *v;if(s->top==s->base)cout<<" 栈是空的!"<<endl;else{cout<<" 栈底: ";for(v=s->base;v!=s->top;v=v+1)cout<< *v<<"->";cout<<" 栈顶!"<<endl<<endl;}}void menu(){cout<<"=====================Menu====================="<<endl;cout<<" * 1-创建一个空栈| 2-判断栈是否空*"<<endl<<endl;cout<<" * 3-数据元素入栈| 4-栈顶元素出栈*"<<endl<<endl;cout<<" * 5-读取栈顶元素| 6-将当前栈置空*"<<endl<<endl;cout<<" * 7-计算元素个数| 8-读取所有元素*"<<endl<<endl;cout<<" * 9-将当前栈销毁| 0-立即退出程序*"<<endl;cout<<"=============================================="<<endl;cout<<" 请输入菜单中的功能所对应的序号:";}int main(){int a,e;SqStack s;do {menu();cin>>a;if( ok==0&&(a!=1&&a!=0))printf(" 多项式还没有建立,请你先建立一个多项式!\n");else{switch(a){case 1:InitStack(&s);break;case 2:IsEmpty(&s);break;case 3:printf(" 请输入你要插入的元素:");scanf("%d",&e);Push(&s,e);break;case 4:Pop(&s);break;case 5:Gettop(&s);break;case 6:MakeEmpty(&s);break;case 7:Getlength(&s);break;case 8:Visit(&s);break;case 9:Destroy(&s);break;case 0:cout<<" 谢谢使用,再见!"<<endl;break;default:cout<<" 输入错误,请核对后重试!"<<endl;break;}}}while (a!=0);return 0;}实验结果(输入和输出):1、初始界面及菜单;2、功能一,建立一个空栈;3、输入一个数据,入栈,作为栈底元素;重复操作8次;4、输入结束以后,功能7,显示栈的元素个数5、功能8,显示栈内所有的元素;6、功能4,删除栈顶元素;7、功能2,判断栈是否为空;8、功能6,将栈置空;9、功能9,销毁空栈;。
数据结构实验报告_栈(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——栈和队列实验报告
数据结构实验报告实验名称:实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
提示:1、可以使用递归或非递归两种方法实现2、实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序:#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数,初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。
实验二—栈、队列的实现实验报告
if(!S.base)
{cout<<"新分配空间失败!!!"<<endl;
exit(0);
}
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
i++;
break;
case 2:
Pop(Stack,x);
cout<<x<<"出栈"<<endl;
break;
case 3:
cout<<"栈顶值为:"<<endl;
GetTop(Stack,y);
break;
case 4:
ClearStack(Stack);
break;
case 5:
cout<<"Exit!!"<<endl;
exit(0);
}
e=*--S.top;
//cout<<"删除成功!!!"<<endl;
}//Pop
void ClearStack(SqStack &S){
//把S置为空栈
if(S.base==S.top)
cout<<"此栈已经为空!!!"<<endl;
S.top=S.base;
}//ClearStack
}
*S.top++=e;
西南科技大学数据结构实验报告栈的基本操作
西南科技大学数据结构实验报告实验名称:栈的基本操作实验环境:windows 7 VS2010实验类别:指导教师:专业班级:姓名:学号:1、掌握栈的链式存储结构2、学会栈基本运算的实现二、实验内容我所做的实验是实验题3.2,编写程序3-2.cpp,实现链栈的各种基本运算,并在此基础上设计一个主程序完成如下功能(1)、初始化链栈s;(2)、判断链栈s是否非空;(3)、依次进栈元素a,b,c,d,e;(4)、判断链栈s是否非空;(5)、输出链栈长度;(6)、输出从栈顶到栈底元素;(7)、输出出链栈序列;(8)、判断链栈s是否非空;(9)、释放链栈。
本次实验我是用C++来完成的,链栈也就是采用单链表实现,链栈的优点是不存在栈满上溢的情况,规定栈的所有操作都是在单链表的表头进行的,所以实现链栈也就是对单链表的简化。
下面具体介绍一下本次实验的实验过程:1、初始化链栈要建立链栈的头结点,并将其next域置为NULL。
2、链栈为空的条件是栈的指针的下一个指向空(s->next==NULL),也就是单链表中没有数据结点。
3、进栈也就是将新数据结点插入到头结点之后。
4、链栈的长度也就是从第一个数据结点开始扫描单链表,从而保存访问的数据结点的个数,然后将其值返回。
5、从栈顶到栈底元素的输出也就是从第一个数据结点开始扫描单链表吗,并输出当前访问结点的数据域值6、输出出栈序列是在栈不为空的条件下,将头结点的指针域所指数据结点的数据域输出,然后将其空间释放,也就是删除。
7、释放链栈也就是对栈的销毁,释放栈占用的全部存储空间四、实验结果本次实验实现了栈的各种基本运算,并对其进行检验,均没有发生错误,符合实验要求。
五、实验心得通过本次实验,可以说我对单链表的操作再一次熟悉了一遍,并且了解到栈在实际应用当中也很广泛,例如在计算器当中的表达式的求值可以用栈来实现,DFS深度优先搜索也可以用栈来实现,从而解决了求解迷宫问题等等。
数据结构实验报告 栈和队列
2007级数据结构实验报告实验名称:实验二栈和队列日期:2008年11月15日1.实验要求实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力实验内容2.1题目1根据栈和队列的抽象数据类型的定义,按要求实现一个栈或一个队列。
要求:1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构存储结构:特殊线性表:栈,队列栈顶 栈底 链栈2.2 关键算法分析共享栈的入栈算法伪码(Push ): 1.如果栈满,抛出上溢异常。
2.判断是插在栈1还是栈2:2.1如果在栈1插入,则栈顶指针top1加1,在top1处填入元素x ; 2.2如果在栈2插入,则栈顶指针top2加1,在top2处填入元素x 。
共享栈的出栈算法伪码(Pop ):1. 判断是在栈1删除还是在栈2删除。
2. 若是在栈1删除,则2.1 若栈1为空栈,抛出下溢异常; 2.2 删除并返回栈1的栈顶元素;3. 若是在栈2删除,则3.1 若栈2为空栈,抛出下溢异常; 3.2 删除并返回栈2的栈顶元素。
非空链队列 空链队列共享栈的取栈顶元素算法伪码(GetTop):1.判断是在栈1取还是栈2取;2.如果在栈1取,则2.1 若栈1不空,返回栈顶元素的值,不删除;2.2 若栈1空,返回0;3.如果在栈2取,则3.1 若栈2不空,返回栈顶元素的值,不删除;3.2 若栈2空,返回0。
链栈的入栈算法伪码(Push):1.申请一个新的结点,数据域为x;2.将新结点插在栈顶;3.栈顶指针重新指向栈顶元素。
链栈的出栈算法伪码(Pop):1.如果栈空,抛出下溢异常;2.暂存栈顶元素;3.将栈顶结点摘链;4.删除该结点,返回该元素的值。
链栈的取栈顶元素算法的伪码(GetTop):1.如果栈非空,返回栈顶元素的值,不删除。
数据结构实验报告三栈的实现
实验报告一、实验题目:栈的实现二、实验目的:掌握栈的特点。
熟悉在栈上进行的各种操作。
三、实验要求: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.基于数组的实现类:。
数据结构实验报告(栈
数据结构实验报告(栈
一、实验名称
栈的实现及应用
二、实验目的
1.了解栈的概念与基本操作。
2.掌握栈的基本实现(栈的存储结构、栈的主要操作和栈的应用)。
3.通过编写程序实现栈的基本操作和应用。
三、实验内容
1.栈的定义:栈是一种具有特定结构的数据类型,其特殊之处在于只能从固定的一端(称为栈顶)进行插入,删除和查找操作。
2.栈的存储结构:栈既可以采用顺序存储结构,也可以采用链式存储结构。
3.栈的基本操作有:进栈(push)、出栈(pop)、查看栈顶元素(get_top)、清空栈(clear)、获取栈长度(length)等。
4.栈的应用:主要用于表达式求值、括号匹配、逆序输出等操作。
五、实验步骤
2.编写程序实现栈结构的创建、进栈、出栈、查看栈顶元素、清空栈、获取栈长度等基本操作。
四、实验结果
1.按照实验要求,成功创建一个栈的数据结构,并实现栈的基本操作。
栈作为常用的一种数据结构,在实际的编程中有广泛的应用。
通过本次实验的学习,对栈的概念、特点、实现方式有了更深刻的了解,同时也掌握了栈的一些应用操作,这对于提高代码效率和解决实际问题有很大的帮助。
栈和队列实验报告
数据结构实验报告顺序栈的实现和基本操作一、需求分析(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;初始条件:栈已存在。
栈的实验报告
栈的实验报告栈的实验报告引言:栈是一种常用的数据结构,它具有先进后出(Last In First Out, LIFO)的特点。
在本次实验中,我们将通过编写代码实现栈的基本操作,并进行相应的测试和分析。
一、栈的定义和基本操作栈是一种线性数据结构,它可以通过数组或链表来实现。
栈的基本操作包括入栈(push)、出栈(pop)、获取栈顶元素(top)以及判断栈是否为空(isEmpty)等。
二、栈的实现在本次实验中,我们选择使用数组来实现栈。
首先,我们需要定义一个栈的结构体,其中包含一个整型数组和一个指向栈顶的指针。
具体的代码如下所示:```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;```接下来,我们可以实现栈的基本操作。
具体的代码如下所示:```c// 初始化栈void initStack(Stack *s) {s->top = -1;}// 判断栈是否为空int isEmpty(Stack *s) {return s->top == -1;}// 判断栈是否已满int isFull(Stack *s) {return s->top == MAX_SIZE - 1; }// 入栈void push(Stack *s, int value) {if (isFull(s)) {printf("Stack is full.\n");return;}s->data[++s->top] = value;}// 出栈int pop(Stack *s) {if (isEmpty(s)) {printf("Stack is empty.\n");return -1;}return s->data[s->top--];}// 获取栈顶元素int top(Stack *s) {if (isEmpty(s)) {printf("Stack is empty.\n");return -1;}return s->data[s->top];}```三、栈的测试与分析为了验证我们实现的栈是否正确,我们可以编写一些测试代码来进行验证。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
typedef struct
{
int *base;
int *top;
int stacksize;
}SqStack;
int InitStack(SqStack &S)
{
S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(int));
printf("\n");
return 0;
}//返回栈顶元素e
void PrintStack(SqStack &S)
{
int *k;
printf("顺序栈中的元素:\n");
for(k=S.base;k!=S.top;k++)
printf("%5d",*k);
printf("\n");
}//遍历顺序栈
}SNode,*Stack;
typedef struct
{
Stack top;
int length;
}SqStack;//定义链式栈的结构体
int InitStack(SqStack &S)
{
S.top=NULL;
S.length=0;
return 0;
}//初始化链式栈
int Push(SqStack &S,int e)
}
printf("选择: ");
scanf("%d",&n);
printf("\n");printf("\n");
}
printf("结束运行。再见!\n");
}
链式栈
#include<stdio.h>
#include<stdlib.h>
typedef struct SNode{
int data;
struct SNode *next;
}
return 0;
}//返回栈顶元素
int PrintStack(SqStack &S)
{
Stack p;
printf("链式队列中的元素");
p=S.top;
if(S.top!=NULL)
{
while(p!=NULL)
{
printf("%5d",p->data);
p=p->next;
else
{
Stack q;
q=S.top;
S.top=S.top->next;
h;
free(q);
}
return 0;
}//删除栈顶元素e
int GetTop(SqStack &S)
{
if(!S.top)return 0;
else
{
printf("返回栈顶元素%5d\n",S.top->data);
case 2:Pop(S,e);PrintStack(S);printf("\n");printf("\n");break;
case 3:Gettop(S,e);printf("\n");printf("\n");break;
case 4:printf("已置空顺序栈");ClearStack(S);printf("\n");printf("\n");break;
printf("\n");printf("\n");
printf("选择: ");
scanf("%d",&n);
printf("\n");printf("\n");
while(n!=0)
{
switch(n)
{
case 1:printf("插入栈顶元素");scanf("%d",&e);Push(S,e);PrintStack(S);printf("\n");printf("\n");break;
if(!S.base)exit(0);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return 0;
}//初始化顺序栈
int Push(SqStack &S,int e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(int *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
e=*--S.top;
printf("删除的栈顶元素%5d",e);
printf("\n");
return 0;
}//删除栈顶元素e
int Gettop(SqStack &S,int e)
{
if(S.top==S.base)return 0;
e=*(S.top-1);
printf("返回的栈顶元素%5d",e);
(6)置空顺序栈。
实验2. 2栈的链式表示和实现
编写一个程序实现链栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能:
(1)初始化链栈。
(2)链栈置空。
(3)入栈。
(4)出栈。
(5)取栈顶元素。
(6)遍历链栈。
顺序栈
#include<stdio.h>
#include<stdlib.h>
#define STACK_INIT_SIZE 100
实验二栈
一、实验目的
1.了解栈的特性。
2.掌握栈的顺序表示和实现。
3.掌握栈的链式表示和实现。
二、实验内容
实验2.1栈的顺序表示和实现
编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能:
(1)初始化顺序栈。
(2)插入元素。
(3)删除栈顶元素。
(4)取栈顶元素。
(5)遍历顺序栈。
{
Stack p;
p=(Stack)malloc(sizeof(SNode));
if(!p)exit(0);
p->data=e;
p->next=S.top;
S.top=p;
S.length++;
return 0;
}//插入元素e
int Pop(SqStack &S)
{
if(!S.top)return 0;
void ClearStack(SqStack &S)
{
S.top=S.base;
}//置空顺序栈
void main()
{
int e,i,n;
SqStack S;
InitStack(S);
printf("1—插入顶元素;2—删除顶元素;3—返回顶元素;4—置空顺序栈;0—结束运行\n");
printf("\n");printf("\n");printf("\n");
if(!S.base)exit(0);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return 0;
}//插入元素e
int Pop(SqStack &S,int e)
{
if(S.top==S.base)return 0;