栈的操作实验报告

栈和队列基本操作实验报告实验目的1. 了解栈和队列的基本概念和特点；2. 掌握栈和队列的基本操作，包括插入、删除、判空、判满等；3. 加深对数据结构的理解，提高编程能力。

实验原理1. 栈(Stack)是一种“先进后出”(Last In First Out，简称LIFO)的数据结构，类似于一摞盘子，最先放入的盘子在最底下，最后放入的盘子在最上面，取出盘子时也是从上往下取出。

2. 队列(Queue)是一种“先进先出”(First In First Out，简称FIFO)的数据结构，类似于排队，先来的人先进队列，后来的人排在后面，服务员按照队列顺序依次为每个人提供服务。

实验内容1. 栈的实现栈的基本操作包括入栈(push)、出栈(pop)、判空(empty)、栈顶(top)。

本次实验选择使用顺序栈来实现，并通过代码模拟栈的基本操作。

在顺序栈的实现中，需要设置栈顶指针(top)、初始化栈、入栈、出栈、判空、判满等操作，其中最关键的是入栈和出栈操作。

入栈操作：在栈顶指针(top)的位置加1，将元素e放到栈顶```void push(SqStack &s, ElemType e){if (s.top == MAXSIZE - 1) // 栈满return;s.top++; // 栈顶指针加1s.data[s.top] = e; // 将元素e放到栈顶return;}```出队操作：将队头元素弹出，队头指针(front)加1实验结果1. 栈的实现通过栈的实现，我们可以进行压入和弹出元素的操作。

下面是一段示例代码：通过本次实验，我学会了栈和队列的基本概念和特点，掌握了栈和队列的基本操作，如插入、删除、判空、判满等。

这些基本操作是数据结构中的重要部分，对于算法的实现与性能优化都有很大的帮助。

此外，在实现中，我们还需要注意栈和队列指针的变化，以及对于空栈和空队列的处理。

通过本次实验，我加深了对数据结构的理解，同时也提升了编程能力。

一、实验背景栈是一种常见的数据结构，它遵循后进先出（LIFO）的原则。

传统的栈只允许在栈顶进行插入和删除操作，而双向栈则允许在栈顶和栈底进行插入和删除操作。

本实验旨在设计并实现一个双向栈，了解其基本原理和操作方法，并探讨其在实际应用中的优势。

二、实验目的1. 理解双向栈的定义、特点及逻辑结构。

2. 掌握双向栈的存储结构表示和实现方法。

3. 熟练掌握双向栈的基本操作，如入栈、出栈、栈顶元素获取等。

4. 分析双向栈在实际应用中的优势。

三、实验内容1. 设计双向栈的数据结构。

双向栈由栈顶和栈底两个指针组成，分别指向栈顶元素和栈底元素。

为了实现栈顶和栈底的插入和删除操作，我们使用两个数组分别存储栈顶元素和栈底元素。

以下是双向栈的数据结构定义：```c#define MAX_SIZE 100 // 定义双向栈的最大容量typedef struct {int top; // 栈顶指针int bottom; // 栈底指针int data[MAX_SIZE]; // 存储栈元素的数组} DStack;```2. 实现双向栈的基本操作。

（1）初始化双向栈```cvoid initDStack(DStack s) {s->top = -1;s->bottom = MAX_SIZE - 1;}```（2）判断双向栈是否为空```cint isEmptyDStack(DStack s) {return s->top == -1;}```（3）判断双向栈是否已满```cint isFullDStack(DStack s) {return s->top == s->bottom + 1;}```（4）入栈操作```cvoid pushDStack(DStack s, int element) { if (isFullDStack(s)) {printf("栈已满，无法入栈。

\n");return;}s->top++;s->data[s->top] = element;}```（5）出栈操作```cint popDStack(DStack s) {if (isEmptyDStack(s)) {printf("栈为空，无法出栈。

栈和队列的操作实验小结一、实验目的本次实验旨在深入理解和掌握栈和队列这两种基本数据结构的基本操作，包括插入、删除、查找等操作，并通过实际操作加深对这两种数据结构特性的理解。

二、实验原理栈（Stack）：栈是一种后进先出（Last In First Out，LIFO）的数据结构，即最后一个进入栈的元素总是第一个出栈。

在计算机程序中，栈常常被用来实现函数调用和递归等操作。

队列（Queue）：队列是一种先进先出（First In First Out，FIFO）的数据结构，即第一个进入队列的元素总是第一个出队。

在计算机程序中，队列常常被用来实现任务的调度和缓冲等操作。

三、实验步骤与结果创建一个空栈和一个空队列。

对栈进行入栈（push）和出栈（pop）操作，观察并记录结果。

可以发现，栈的出栈顺序与入栈顺序相反，体现了后进先出的特性。

对队列进行入队（enqueue）和出队（dequeue）操作，观察并记录结果。

可以发现，队列的出队顺序与入队顺序相同，体现了先进先出的特性。

尝试在栈和队列中查找元素，记录查找效率和准确性。

由于栈和队列的特性，查找操作并不像在其他数据结构（如二叉搜索树或哈希表）中那样高效。

四、实验总结与讨论通过本次实验，我更深入地理解了栈和队列这两种数据结构的基本特性和操作。

在实际编程中，我可以根据需求选择合适的数据结构来提高程序的效率。

我注意到，虽然栈和队列在某些操作上可能不如其他数据结构高效（如查找），但它们在某些特定场景下具有无可替代的优势。

例如，在实现函数调用和递归时，栈的特性使得它成为最自然的选择；在实现任务调度和缓冲时，队列的特性使得它成为最佳选择。

我也认识到，不同的数据结构适用于解决不同的问题。

在选择数据结构时，我需要考虑数据的特性、操作的频率以及对时间和空间复杂度的需求等因素。

通过实际操作，我对栈和队列的实现方式有了更深入的理解。

例如，我了解到栈可以通过数组或链表来实现，而队列则可以通过链表或循环数组来实现。

实验项目名称栈的应用一．实验目的掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。

三．实验内容1．顺序栈的实现和运算2．链栈的实现和运算四、主要仪器设备及耗材VC++6.0运行环境实现其操作五．程序算法1>.顺序栈的实现a.顺序栈的数据类型CONST int maxsize=maxlen; //定义栈的最大容量为maxlenStruct seqstack{elemtype stack[maxsize]; //将栈中元素定义为elemtype类型int top; //指向栈顶位置的指针（数组编号）}b.初始化栈void inistack(seqstack &s){s.top=0;}c.进栈void push(seqstack &s, elemtype x){if (s.top==maxsize-1} cout<<”overflow”;else{s.top++;s.stack[s.top]=x;}}d.）退栈void pop(seqstack &s){if (s.top= =0) cout<<”underflow”; elses.top--;}e.）取栈顶元素elemtype gettop(seqstack s){if (s.top= =0){ cout<<”underflow”;return 0;}else return s.stack[s.top];}f.）判栈空否int empty(seqstack s){if (s.top= =0) return 1;else return 0;}2>.链栈的实现a.栈初始化void inistack(link *top){ top->next=NULL;}b.进栈运算void push(link *top,int x){ link *s;s=new link;s->data=x;s->next=top->next; //头插法top->next=s; }c.退栈运算void pop(link *top){link *s;s=top->next;if(s!=NULL){top->next=s->next;delete(s);}}d.取栈顶元素elemtype gettop(link *top){if(top->next!=NULL)return(top->next->data);elsereturn(NULL);}e.判栈空int empty(link *top){if(top->next==NULL)return(1);elsereturn(0);}六.程序源代码1>.顺序栈的实现代码#include<iostream.h>#define max 100struct seqstack{int stack[max];int top;};void init(seqstack &s)/*初始化*/{s.top=0;//return 1;}void push(seqstack &s,int x) /*入栈操作*/ {if (s.top==max)cout<<"the stack is overflow!";else{s.top++;s.stack[s.top]=x;}}void display(seqstack &s) /*显示栈所有数据*/{int t;t=s.top;if(t==0)cout<<"the stack is empty!";else{ cout<<"从栈顶到栈底输出:"<<endl;while(t!=0){cout<<s.stack[t]<<"->";t--;}}cout<<endl;}void pop(seqstack &s)/*出栈操作并返回被删除的那个记录*/ {if(s.top==0)cout<<"the stack is empty!";elses.top--;}int gettop(seqstack s) /*得到栈顶数*/{if(s.top==0)return 0;elsereturn s.stack[s.top];}int IsEmpty(seqstack s) {if(s.top == 0) return 1;return 0;}main(){seqstack p;int i,x,y;init(p);cout<<"输入元素到0时为止"<<endl;cin>>i;while(i){push(p,i);cin>>i;}pop(p);x=gettop(p);cout<<"x="<<x<<endl;display(p);while(p.top!=0)pop(p);y=IsEmpty(p);if(y==1)cout<<"空栈";elsecout<<"非空栈";cout<<endl;}2>.链栈的实现代码#include <iostream.h>typedef struct QNode{char data;QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;InitQueue(LinkQueue &Q){Q.front=Q.rear=new QNode;Q.front->next=NULL;return 0;}EnQueue(LinkQueue &Q,char e){QueuePtr p;p=new QNode;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return 0;}void disp(LinkQueue &Q) //打印队列{QueuePtr p;p=Q.front->next;while(p!=NULL){cout<<p->data<<"->";p=p->next;}}DeQueue(LinkQueue &Q,char &e){QueuePtr p;if(Q.front==Q.rear)return 1;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;delete p;return 0;}void main(){LinkQueue Q;char e,e1;InitQueue(Q);cout<<"输入队列元素,0时结束："<<endl;cin>>e;while(e!='0'){EnQueue(Q,e);cin>>e;}cout<<"队列为："<<endl;disp(Q);DeQueue(Q,e1);cout<<endl<<"执行一次删除队头，删除的元素是:"<<e1<<endl;cout<<"队列为:"<<endl;disp(Q);cout<<endl;}七．实验数据及实验结果1>.顺序栈的实验结果2>.链栈的实验结果八、思考讨论题或体会或对改进实验的建议（1）体会a．C++语言知识不懂，需要好好学习；b．对单链表不够熟悉，要多练习创建单链表及其基本操作。

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

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

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

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

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

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

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

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

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

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

- 获取栈顶元素：返回栈顶元素，但不删除。

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

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

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

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

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

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

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

算法步骤如下：（1）使用顺序栈或链栈存储字符序列。

（2）从字符序列的头部开始，依次将字符入栈。

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

（4）如果所有字符均与栈顶元素相等，则字符序列为回文。

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

算法步骤如下：（1）创建一个空栈，用于存储逆转后的栈内容。

（2）从原栈中依次将元素出栈，并依次入新栈。

（3）将新栈的内容赋值回原栈，实现栈内容的逆转。

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

栈与队列实验报告总结实验报告总结：栈与队列一、实验目的本次实验旨在深入理解栈（Stack）和队列（Queue）这两种基本的数据结构，并掌握其基本操作。

通过实验，我们希望提高自身的编程能力和对数据结构的认识。

二、实验内容1.栈的实现：我们首先使用Python语言实现了一个简单的栈。

栈是一种后进先出（LIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的栈操作：push（插入元素）和pop（删除元素）。

2.队列的实现：然后，我们实现了一个简单的队列。

队列是一种先进先出（FIFO）的数据结构，支持元素的插入和删除操作。

在本次实验中，我们实现了两个基本的队列操作：enqueue（在队尾插入元素）和dequeue（从队头删除元素）。

3.栈与队列的应用：最后，我们使用所实现的栈和队列来解决一些实际问题。

例如，我们使用栈来实现一个算术表达式的求值，使用队列来实现一个简单的文本行编辑器。

三、实验过程与问题解决在实现栈和队列的过程中，我们遇到了一些问题。

例如，在实现栈的过程中，我们遇到了一个“空栈”的错误。

经过仔细检查，我们发现是因为在创建栈的过程中没有正确初始化栈的元素列表。

通过添加一个简单的初始化函数，我们解决了这个问题。

在实现队列的过程中，我们遇到了一个“队列溢出”的问题。

这是因为在实现队列时，我们没有考虑到队列的容量限制。

通过添加一个检查队列长度的条件语句，我们避免了这个问题。

四、实验总结与反思通过本次实验，我们对栈和队列这两种基本的数据结构有了更深入的理解。

我们掌握了如何使用Python语言实现这两种数据结构，并了解了它们的基本操作和实际应用。

在实现栈和队列的过程中，我们也学到了很多关于编程的技巧和方法。

例如，如何调试代码、如何设计数据结构、如何优化算法等。

这些技巧和方法将对我们今后的学习和工作产生积极的影响。

然而，在实验过程中我们也发现了一些不足之处。

例如，在实现栈和队列时，我们没有考虑到异常处理和性能优化等方面的问题。

《数据结构》实验报告◎实验题目: 栈的应用。

◎实验目的：熟悉掌握对栈的应用和基本操作。

◎实验内容：用算符优先法对算术表达式求值。

一、需求分析通过程序设计实现算符优先法：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通过调用其它函数实现了算符优先法计算表达式，因此主函数主要通过调用该函数进行运算。

栈和队列实验报告总结一、实验目的本次实验的主要目的是掌握栈和队列这两种数据结构的基本概念和操作方法，以及了解它们在计算机程序设计中的应用。

二、实验原理1. 栈栈是一种后进先出（LIFO）的数据结构，它可以看作是一种线性表。

栈顶指针指向栈顶元素，每次插入或删除元素时，都会改变栈顶指针的位置。

常见的操作有入栈（push）、出栈（pop）、取栈顶元素（top）等。

2. 队列队列是一种先进先出（FIFO）的数据结构，它也可以看作是一种线性表。

队头指针指向队头元素，队尾指针指向队尾元素。

常见的操作有入队（enqueue）、出队（dequeue）、取队头元素（front）等。

三、实验内容与步骤1. 栈本次实验中我们需要完成以下操作：① 初始化一个空栈；② 将10个整数依次压入栈中；③ 弹出3个整数并输出；④ 将5个整数依次压入栈中；⑤ 弹出所有整数并输出。

具体步骤如下：Step 1：定义一个Stack类，并在其中定义初始化、入栈、出栈、取栈顶元素等方法；Step 2：在主函数中创建一个Stack对象，并调用初始化方法；Step 3：使用循环将10个整数依次压入栈中；Step 4：使用循环弹出3个整数并输出；Step 5：使用循环将5个整数依次压入栈中；Step 6：调用出栈方法弹出所有整数并输出。

2. 队列本次实验中我们需要完成以下操作：① 初始化一个空队列；② 将10个整数依次加入队列中；③ 弹出3个整数并输出；④ 将5个整数依次加入队列中；⑤ 弹出所有整数并输出。

具体步骤如下：Step 1：定义一个Queue类，并在其中定义初始化、入队、出队、取队头元素等方法；Step 2：在主函数中创建一个Queue对象，并调用初始化方法；Step 3：使用循环将10个整数依次加入队列中；Step 4：使用循环弹出3个整数并输出；Step 5：使用循环将5个整数依次加入队列中；Step 6：调用出队方法弹出所有整数并输出。

《数据结构》实验报告一软件132201300514211徐蜀实验二栈和队列的基本操作及其应用一、实验目的1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。

2、掌握栈和队列的特点，即后进先出和先进先出的原则。

3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。

二、实验内容1．回文判断三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。

2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。

3、严格按照数据结构实验报告模板和规范，及时完成实验报告。

四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（函数）的伪码算法、函数实现、程序编码、调试与分析。

附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、栈的初始长度与需要再增加的长度#define STACK_INIT_SIZE 100;#define STACKINCREMENT 10;typedef char SElemType;//定义SElemType为char型2、栈的顺序存储表示typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;3、队列的链式表示方法typedef struct QNode {SElemType data;struct QNode *next; } QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4、初始化栈/* 函数功能：对栈进行初始化参数：栈（SqStack &S）成功返回1，否则返回0 */int InitStack(SqStack &S){S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));//申请内存if(!S.base) //判断有无申请到空间return ERROR; //没有申请到内存，返回0S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}5、入栈操作/* 函数功能：将元素入栈参数：栈（SqStack &S）,插入元素e插入成功返回1，否则返回0 */int 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) //判断是否申请成功return ERROR; //不成功返回0S.top = S.base + S.stacksize;S.stacksize += STACKINCREMENT;}*S.top++ = e;return OK;}6、出栈操作/* 函数功能：将栈中的元素弹出参数：栈(SqStack &S),记录元素e */int Pop(SqStack &S, SElemType &e){if(S.top == S.base) //判断栈是否为空return ERROR;e = *(--S.top) ;return OK;}7、初始化队列/* 函数功能：初始化队列参数：队列（LinkQueue &Q）成功返回1，否则返回0 */int InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));//申请结点的内存if(!Q.front) //判断有无申请到空间return ERROR; //没有返回0Q.front ->next = NULL;return OK;}8.在队列队尾插入元素/* 函数功能：在队列队尾插入元素参数：队列（LinkQueue &Q），插入元素e成功返回1，否则返回0 */ int EnQueue(LinkQueue &Q, QElemType e){p = (QueuePtr)malloc(sizeof(QNode)); //申请新的结点if(!p)return ERROR;p -> data = e;p -> next = NULL;Q.rear -> next = P;Q.rear = p;return OK;}9.删除队头元素/* 函数功能：删除对头元素参数：队列（LinkQueue &Q），记录值e成功返回1，否则返回0 */ int DeQueue(LinkQueue &Q, QElemType &e){if(Q.front == Q.rear) //判断队列是否为空return ERROR;p = Q.front -> next;e = p -> data;Q.front -> next = p -> next;if(Q.rear == p)Q.rear = Q.front;free(p);return OK;}10、主函数int main(){SqStack S; //声明一个栈LinkQueue Q; //声明一个队列char m,k,c;int n=0,i,j,t=0,z=0;while(!t){cout << "请输入你要判断回文的字符串，输入@结束：";InitQueue (Q);InitStack (S);while((c=getchar())!='@')//对字符的判断不断输入字符{EnQueue (Q,c);Push (S,c);n++;}for( j=1;j<=n;j++){OutQueue (Q,m);Pop (S,k);if(m!=k)break;}if(j>n) //如果j > n则说明全部相等cout << "这个字符串不是回文字符串" << endl;elsecout << "这个字符串是回文字符串" << endl;}return 0;}说明：通过调用序列号不同的函数进行各种操作。

栈和队列实验报告实验名称：栈和队列的实验研究摘要：本实验旨在通过设计并实现基于栈和队列的算法，探索其在数据结构和算法中的应用。

通过实验比较栈和队列的性能差异和适用场景，加深对栈和队列的理解和应用。

实验结果表明，栈和队列在不同的问题场景中具有不同的优势和适用性。

关键词：栈、队列、数据结构、算法、应用一、引言栈和队列是数据结构中常见且重要的两种数据结构，它们分别以LIFO（Last In First Out，后进先出）和FIFO（First In First Out，先进先出）的方式操作数据，广泛应用于各领域的编程和算法设计中。

本实验通过实现栈和队列相关操作的算法，探索它们在实际应用中的效率和优势。

二、实验设计与实现1.实验设计本实验采用C++语言来实现栈和队列的操作，并编写相应的算法来解决一些典型问题。

实验将比较栈和队列在以下几个方面的性能差异：a)插入操作的性能b)删除操作的性能c)查询操作的性能d)栈和队列的空间占用情况2.实验步骤a)设计栈的数据结构和相关操作的算法。

b)设计队列的数据结构和相关操作的算法。

c)分别使用栈和队列来解决一个典型问题，并比较它们的效率。

d)分析实验结果，总结栈和队列的适用场景和优势。

三、实验结果与分析1.栈的性能比较在本次实验中，我们使用栈来解决斐波那契数列问题。

首先，我们设计了一个栈的数据结构，并实现了如下操作：a) 入栈（push）：将元素添加到栈顶。

b) 出栈（pop）：将栈顶元素移出栈。

c) 查询栈顶元素（top）：返回栈顶元素。

对比使用数组和链表实现栈的性能，我们发现使用链表实现的栈在插入和删除操作上有更好的性能表现，而使用数组实现的栈在查询操作上更高效。

这是因为使用链表实现的栈不需要移动大量元素，而使用数组实现的栈可以通过索引直接访问任意位置的元素。

2.队列的性能比较在本次实验中，我们使用队列来解决击鼓传花问题。

首先，我们设计了一个队列的数据结构，并实现了如下操作：a) 入队（enqueue）：将元素添加到队列末尾。