实验3 栈和队列
栈和队列的实验报告
![栈和队列的实验报告](https://img.taocdn.com/s3/m/5d76219e5122aaea998fcc22bcd126fff6055d59.png)
栈和队列的实验报告栈和队列的实验报告引言:栈和队列是计算机科学中常用的数据结构,它们在算法设计和程序开发中起着重要的作用。
本实验旨在通过实际操作和观察,深入理解栈和队列的概念、特点以及它们在实际应用中的作用。
一、栈的实验1.1 栈的定义和特点栈是一种具有特殊操作约束的线性数据结构,它的特点是“先进后出”(Last-In-First-Out,LIFO)。
栈的操作包括入栈(push)和出栈(pop),入栈操作将元素放入栈顶,出栈操作将栈顶元素移除。
1.2 实验步骤在本次实验中,我们使用编程语言实现了一个栈的数据结构,并进行了以下实验步骤:1.2.1 创建一个空栈1.2.2 向栈中依次压入若干元素1.2.3 查看栈顶元素1.2.4 弹出栈顶元素1.2.5 再次查看栈顶元素1.3 实验结果通过实验,我们观察到栈的特点:最后入栈的元素最先出栈。
在实验步骤1.2.2中,我们依次压入了元素A、B和C,栈顶元素为C。
在实验步骤1.2.4中,我们弹出了栈顶元素C,此时栈顶元素变为B。
二、队列的实验2.1 队列的定义和特点队列是一种具有特殊操作约束的线性数据结构,它的特点是“先进先出”(First-In-First-Out,FIFO)。
队列的操作包括入队(enqueue)和出队(dequeue),入队操作将元素放入队尾,出队操作将队头元素移除。
2.2 实验步骤在本次实验中,我们使用编程语言实现了一个队列的数据结构,并进行了以下实验步骤:2.2.1 创建一个空队列2.2.2 向队列中依次插入若干元素2.2.3 查看队头元素2.2.4 删除队头元素2.2.5 再次查看队头元素2.3 实验结果通过实验,我们观察到队列的特点:最先入队的元素最先出队。
在实验步骤2.2.2中,我们依次插入了元素X、Y和Z,队头元素为X。
在实验步骤2.2.4中,我们删除了队头元素X,此时队头元素变为Y。
三、栈和队列的应用栈和队列在实际应用中有广泛的应用场景,下面简要介绍一些常见的应用:3.1 栈的应用3.1.1 表达式求值:通过栈可以实现对表达式的求值,如中缀表达式转换为后缀表达式,并计算结果。
数据结构栈和队列实验报告
![数据结构栈和队列实验报告](https://img.taocdn.com/s3/m/37c6774a02d8ce2f0066f5335a8102d276a261c6.png)
数据结构栈和队列实验报告实验报告:数据结构栈和队列一、实验目的1.了解栈和队列的基本概念和特点;2.掌握栈和队列的基本操作;3.掌握使用栈和队列解决实际问题的方法。
二、实验内容1.栈的基本操作实现;2.队列的基本操作实现;3.使用栈和队列解决实际问题。
三、实验原理1.栈的定义和特点:栈是一种具有后进先出(LIFO)特性的线性数据结构,不同于线性表,栈只能在表尾进行插入和删除操作,称为入栈和出栈操作。
2.队列的定义和特点:队列是一种具有先进先出(FIFO)特性的线性数据结构,不同于线性表,队列在表头删除元素,在表尾插入元素,称为出队和入队操作。
3.栈的基本操作:a.初始化:建立一个空栈;b.入栈:将元素插入栈的表尾;c.出栈:删除栈表尾的元素,并返回该元素;d.取栈顶元素:返回栈表尾的元素,不删除。
4.队列的基本操作:a.初始化:建立一个空队列;b.入队:将元素插入队列的表尾;c.出队:删除队列表头的元素,并返回该元素;d.取队头元素:返回队列表头的元素,不删除。
四、实验步骤1.栈的实现:a.使用数组定义栈,设置栈的大小和栈顶指针;b.实现栈的初始化、入栈、出栈和取栈顶元素等操作。
2.队列的实现:a.使用数组定义队列,设置队列的大小、队头和队尾指针;b.实现队列的初始化、入队、出队和取队头元素等操作。
3.使用栈解决实际问题:a.以括号匹配问题为例,判断一个表达式中的括号是否匹配;b.使用栈来实现括号匹配,遍历表达式中的每个字符,遇到左括号入栈,遇到右括号时将栈顶元素出栈,并判断左右括号是否匹配。
4.使用队列解决实际问题:a.以模拟银行排队问题为例,实现一个简单的银行排队系统;b.使用队列来模拟银行排队过程,顾客到达银行时入队,处理完业务后出队,每个顾客的业务处理时间可以随机确定。
五、实验结果与分析1.栈和队列的基本操作实现:a.栈和队列的初始化、入栈/队、出栈/队以及取栈顶/队头元素等操作均能正常运行;b.栈和队列的时间复杂度均为O(1),操作效率很高。
数据结构实验三栈和队列的应用
![数据结构实验三栈和队列的应用](https://img.taocdn.com/s3/m/138004cf5fbfc77da269b172.png)
第三章栈和队列的应用【实验目的】1.熟练掌握栈和队列的结构,以及这两种数据结构的特点;2.能够在两种存储结构上实现栈的基本运算,特别注意栈满和栈空的判断条件及描述方法;3.熟练掌握链队列和循环队列的基本运算,并特别注意队列满和队列空的判断条件和描述方法;第一节知识准备一、栈:1. 基本概念栈是一种限定仅在表的一端进行插入与删除操作的线性表。
允许进行插入与删除操作的这一端称为栈顶,而另一端称为栈底,不含元素的空表称为空栈,插入与删除分别称进栈与出栈。
由于插入与删除只能在同一端进行,所以较先进入栈的元素,在进行出栈操作时,要比较后才能出栈。
特别是,最先进栈者,最后才能出栈,而最晚进栈者,必最先出栈。
因此,栈也称作后进先出(Last In First Out)的线性表,简称LIFO表。
栈示意图见图3-12. 栈的抽象数据类型定义:ADT Stack{数据对象:D={ | ∈ElemSet, i=1,2,...,n, n>=0}数据关系:R1={< , >| , ∈D, i=2,...,n}基本操作:InitStack(&S) 构造一个空栈SStackEmpty(S) 判断栈S是否为空StackLength(S) 返回栈S的元素个数,即栈的长度GetTop(S,&e) 取栈S的栈顶元素Push(&S,e) 将元素e入栈Pop(&S,&e) 删除S的栈顶元素并用e返回其值(即出栈)}ADT Stack3. 栈的表示:栈有两种存储表示方法:顺序存储结构和链式存储结构。
(1)顺序存储结构:#define STACK_INIT_SIZE 100; //存储空间初始分配量#define STACKINCREMENT 10; //存储空间分配增量typedef struct{SElemType *base; //栈底指针SElemType *top; //栈顶指针int StackSize; //栈的当前容量}SqStack;(2)链式存储结构:Typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode, *LinkList;二、队列:1. 与栈相对应,队列是一种先进先出的线性表。
数据结构栈和队列实验报告
![数据结构栈和队列实验报告](https://img.taocdn.com/s3/m/5b2598c4951ea76e58fafab069dc5022abea4649.png)
数据结构栈和队列实验报告数据结构栈和队列实验报告1.实验目的本实验旨在通过设计栈和队列的数据结构,加深对栈和队列的理解,并通过实际操作进一步掌握它们的基本操作及应用。
2.实验内容2.1 栈的实现在本实验中,我们将使用数组和链表两种方式实现栈。
我们将分别实现栈的初始化、入栈、出栈、判断栈是否为空以及获取栈顶元素等基本操作。
通过对这些操作的实现,我们可将其用于解决实际问题中。
2.2 队列的实现同样地,我们将使用数组和链表两种方式实现队列。
我们将实现队列的初始化、入队、出队、判断队列是否为空以及获取队头元素等基本操作。
通过对这些操作的实现,我们可进一步了解队列的特性,并掌握队列在实际问题中的应用。
3.实验步骤3.1 栈的实现步骤3.1.1 数组实现栈(详细介绍数组实现栈的具体步骤)3.1.2 链表实现栈(详细介绍链表实现栈的具体步骤)3.2 队列的实现步骤3.2.1 数组实现队列(详细介绍数组实现队列的具体步骤)3.2.2 链表实现队列(详细介绍链表实现队列的具体步骤)4.实验结果与分析4.1 栈实验结果分析(分析使用数组和链表实现栈的优缺点,以及实际应用场景)4.2 队列实验结果分析(分析使用数组和链表实现队列的优缺点,以及实际应用场景)5.实验总结通过本次实验,我们深入了解了栈和队列这两种基本的数据结构,并利用它们解决了一些实际问题。
我们通过对数组和链表两种方式的实现,进一步加深了对栈和队列的理解。
通过实验的操作过程,我们也学会了如何设计和实现基本的数据结构,这对我们在日后的学习和工作中都具有重要意义。
6.附件6.1 源代码(附上栈和队列的实现代码)6.2 实验报告相关数据(附上实验过程中所产生的数据)7.法律名词及注释7.1 栈栈指的是一种存储数据的线性数据结构,具有后进先出(LIFO)的特点。
栈的操作主要包括入栈和出栈。
7.2 队列队列指的是一种存储数据的线性数据结构,具有先进先出(FIFO)的特点。
数据结构实验三栈和队列的应用
![数据结构实验三栈和队列的应用](https://img.taocdn.com/s3/m/fd4318a8f80f76c66137ee06eff9aef8941e48a0.png)
数据结构实验三栈和队列的应用数据结构实验三:栈和队列的应用在计算机科学领域中,数据结构是组织和存储数据的重要方式,而栈和队列作为两种常见的数据结构,具有广泛的应用场景。
本次实验旨在深入探讨栈和队列在实际问题中的应用,加深对它们特性和操作的理解。
一、栈的应用栈是一种“后进先出”(Last In First Out,LIFO)的数据结构。
这意味着最后进入栈的元素将首先被取出。
1、表达式求值在算术表达式的求值过程中,栈发挥着重要作用。
例如,对于表达式“2 + 3 4”,我们可以通过将操作数压入栈,操作符按照优先级进行处理,实现表达式的正确求值。
当遇到数字时,将其压入操作数栈;遇到操作符时,从操作数栈中弹出相应数量的操作数进行计算,将结果压回操作数栈。
最终,操作数栈中的唯一值就是表达式的结果。
2、括号匹配在程序代码中,检查括号是否匹配是常见的任务。
可以使用栈来实现。
遍历输入的字符串,当遇到左括号时,将其压入栈;当遇到右括号时,弹出栈顶元素,如果弹出的左括号与当前右括号类型匹配,则继续,否则表示括号不匹配。
3、函数调用和递归在程序执行过程中,函数的调用和递归都依赖于栈。
当调用一个函数时,当前的执行环境(包括局部变量、返回地址等)被压入栈中。
当函数返回时,从栈中弹出之前保存的环境,继续之前的执行。
递归函数的执行也是通过栈来实现的,每次递归调用都会在栈中保存当前的状态,直到递归结束,依次从栈中恢复状态。
二、队列的应用队列是一种“先进先出”(First In First Out,FIFO)的数据结构。
1、排队系统在现实生活中的各种排队场景,如银行排队、餐厅叫号等,可以用队列来模拟。
新到达的顾客加入队列尾部,服务完成的顾客从队列头部离开。
通过这种方式,保证了先来的顾客先得到服务,体现了公平性。
2、广度优先搜索在图的遍历算法中,广度优先搜索(BreadthFirst Search,BFS)常使用队列。
从起始节点开始,将其放入队列。
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
![国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案](https://img.taocdn.com/s3/m/99a0c842af45b307e9719729.png)
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)出栈/入队的元素依次为:");
实验三 栈与队列
![实验三 栈与队列](https://img.taocdn.com/s3/m/69f9c02abcd126fff7050b7b.png)
实验三栈与队列一、实验目的1.熟练掌握栈和队列的特点2.掌握栈的定义和基本操作,熟练掌握链栈的操作及应用3.掌握对列的定义和基本操作,熟练掌顺序队列的操作及应用, 掌握环形队列的入队和出队等基本操作加深对栈结构和队列结构的理解.逐步培养解决实际问题的编程能力二、实验内容。
1.定义链栈,完成栈的基本操作,测试.2.用栈解决表达式计算问题。
基本要求:操作数为0到9间的整数。
提高要求:操作数为浮点数。
3.根据所给代码求解迷宫问题.基本要求:找到其中一条路径,并输出。
提高要求:找出所有可能的路径,并一一输出.4.定义顺序队列,完成队列的基本操作,测试.5.用队列解决电线布线问题;(起始点0,障碍-2,通路-1)迷宫问题所用数据如下,请在报告中用笔标出找到的路径布线问题所用数据如下,A始点,B是终点,请在报告中用笔标出找到的路径(2,1)(5,3)三、实验环境1.pc机,windows xp操作系统2.VC++6.0软件四、实验步骤实验一:#include<assert.h>#include<iostream>#include"stack"using namespace std;const int maxSize=50;const int stackIncreament=20;template<class T>class Stack{public:Stack(){}virtual bool Push(T& x)=0;virtual bool Pop(T& x)=0;virtual bool getTop(T& x)=0;virtual bool IsEmpty()const=0;virtual bool IsFull()const=0;virtual int getSize()const=0;};template<class T>class SeqStack:public Stack<T>{public:SeqStack(int sz):top(-1),maxSize(sz){elements = new T[maxSize];assert(elements!=NULL);}~SeqStack(){delete []elements;}bool Push(T& x); //入栈bool Pop(T& x); //退栈bool getTop(T& x);bool IsEmpty()const //判断栈空 {return(top==-1)? true:false;}bool IsFull()const //判断栈满 {return(top==maxSize-1)?true:false;}int getSize()const //栈内元素个数{return top+1;}void MakeEmpty() //清空栈内容{top=-1;}void overflowProcess();void show1(SeqStack<T> &s);void show2(SeqStack<T> &s);private:T *elements;int top;int maxSize;};template<class T>void SeqStack<T>::overflowProcess(){T * newArray=new T[maxSize+stackIncreament];if(newArray=NULL){cerr<<"存储分配失败"<<endl;exit(1);}for(int i=0;i<=top;i++)newArray[i]=elements[i];maxSize=maxSize+stackIncreament;delete []elements;elements=newArray;}template<class T> //入栈bool SeqStack<T>::Push(T &x){elements[++top]=x;return true;}template<class T> //出栈bool SeqStack<T>::Pop(T &x){x=elements[top--];return true;}template<class T>bool SeqStack<T>::getTop(T &x){if(IsEmpty()==true)return false;x=elements[top];return true;}template<class T>void SeqStack<T>::show1(SeqStack<T> &s){for(int i=0;i<=s.top;i++)cout<<s.elements[i];cout<<endl;}template<class T>void SeqStack<T>::show2(SeqStack<T> &s){for(int i=s.top;i>=0;i--)cout<<s.elements[i];cout<<endl;}void main(){int a;char s;SeqStack<char> stack(5);cout<<"初始化:maxsize=5"<<endl;cout<<"------------------------------菜单--------------------------------------"<<endl;cout<<"1.判断栈空"<<endl;cout<<"2.入栈"<<endl;cout<<"3.出栈"<<endl;cout<<"4.判断栈满"<<endl;cout<<"5.取栈顶"<<endl;cout<<"6.元素个数"<<endl;cout<<"7.输出栈"<<endl;cout<<"8.连续出栈"<<endl;cout<<"9.退出"<<endl;while(1){cout<<"请输入你的选择:";cin>>a;if(a==9)break;else{switch(a){case 1:{if(stack.IsEmpty())cout<<"栈为空"<<endl;elsecout<<"栈不为空"<<endl;break;}case 2:{if(stack.IsFull()){cout<<"栈满"<<endl;break;}cout<<"入栈:";cin>>s;stack.Push(s);break;}case 3:{if(stack.IsEmpty()){cout<<"栈空"<<endl;break;}cout<<"出栈:";cin>>s;stack.Pop(s);break;}case 4:{if(stack.IsFull())cout<<"栈为满"<<endl;elsecout<<"栈不为满"<<endl;break;}case 5:{cout<<"栈顶为:";stack.getTop(s);cout<<s;cout<<endl;break;}case 6:{cout<<"元素个数为:";cout<<stack.getSize();cout<<endl;break;}case 7:{cout<<"输出栈:";stack.show1(stack);break;}case 8:{cout<<"连续出栈:";stack.show2(stack);break;}}}}}实验二:#include<assert.h>#include<iostream>#include<fstream>#include<math.h>#include<stack>#include<string>using namespace std;const int maxSize=50;const int stackIncreament=20;class Calculator{public:Calculator(){};void Run(string out);void Clear();void print();int isp(char ch);int icp(char ch);bool isdigit(char ch);string postfix(string in);private:stack<double> s;stack<int>d;void AddOperand(double value);bool get2Operands(double& left,double& right); void DoOperator(char op);};int Calculator::isp(char ch){switch(ch){case'#':return 0;break;case'(':return 1;break;case'*':case'/':case'%':return 5;break;case'+':case'-':return 3;break;case')':return 6;break;}}int Calculator::icp(char ch){switch(ch){case'#':return 0;break;case'(':return 6;break;case'*':case'/':case'%':return 4;break;case'+':case'-':return 2;break;case')':return 1;break;}}bool Calculator::isdigit(char ch){if(ch>='0'&&ch<='9')return true;elsereturn false;}string Calculator::postfix(string in) {stack<char> s;char ch='#',ch1,op;string out;s.push(ch); //输入流要构造 for(int i=0;;){ch=in.at(i);if(isdigit(ch)){out+=ch;i++;}else{ch1=s.top();if(isp(ch1)<icp(ch)){s.push(ch);i++;}else if(isp(ch1)>icp(ch)){op=s.top();s.pop();out+=op;}else{op=s.top();s.pop();if(op=='(')i++;}}if(s.empty()&&ch=='#')break;}cout<<out;return out;}void Calculator::DoOperator(char op) {double left,right,value;bool result;result=get2Operands(left,right);if(result==true)switch(op){case'+':value=left+right;d.push(value);break;case'-':v alue=left-right;d.push(value);break;case'*':value=left*right;d.push(value);break;case'/':if(right==0.0){cerr<<"Divide by 0!"<<endl;Clear();}else{value=left/right;d.push(value);}break;}elseClear();}bool Calculator::get2Operands(double& left,double& right) {if(d.empty()==true){cerr<<"缺少右操作数!"<<endl;return false;}right=d.top();d.pop();if(d.empty()==true){cerr<<"缺少左操作数!"<<endl;return false;}left=d.top();d.pop();return true;}void Calculator::AddOperand(double value) {s.push(value);}void Calculator::Run(string out){char ch;for(int i=0;i<out.size();i++){ch=out.at(i);switch(ch){case'+':case'-':case'*':case'/':DoOperator(ch);break;default:int ch_=ch-48;d.push(ch_);}}}void Calculator::Clear(){while(!s.empty())s.pop();}void Calculator::print(){ i nt t;t=d.top();cout<<t<<endl;Clear();}void main(){string in,out;cin>>in;Calculator c;out=c.postfix(in);c.Run(out);cout<<endl;c.print();}实验三:#include<iostream>#include<stack>#include<string>using namespace std;const int m=7;const int p=7;int maze[m+2][p+2];int mark[m+2][p+2];struct offsets{int a,b;char* dir;}move[8]={{-1,0,"N"},{-1,1,"NE"},{0,1,"E"},{1,1,"SE"},{1,0,"S"} ,{1,-1,"SW"},{0,-1,"W"},{-1,-1,"NW"}};struct items{int x,y,dir;}item[(m+2)*(p+2)];void show(stack<items> &st){items it;for(;;){it=st.top();cout<<it.x<<" "<<it.y<<" "<<move[it.dir].dir<<endl;st.pop();if(st.empty())return;}}int path(int n,int q) //迷宫算法{int i,j,d,g,h;for(i=0;i<p+2;i++)maze[i][0]=maze[i][p+1]=maze[0][i]=maze[m+1][i]=1;maze[1][1]=0;maze[1][2]=1;maze[1][3]=1;maze[1][4]=0;maze[1][5]= 0;maze[1][6]=0;maze[1][7]=0;maze[2][1]=0;maze[2][2]=0;maze[2][3]=1;maze[2][4]=1;maze[2][5]= 0;maze[2][6]=0;maze[2][7]=0;maze[3][1]=1;maze[3][2]=0;maze[3][3]=0;maze[3][4]=0;maze[3][5] =1;maze[3][6]=0;maze[3][7]=0;maze[4][1]=0;maze[4][2]=0;maze[4][3]=0;maze[4][4]=1;maze[4][5] =1;maze[4][6]=0;maze[4][7]=1;maze[5][1]=1;maze[5][2]=0;maze[5][3]=0;maze[5][4]=0;maze[5][5] =1;maze[5][6]=0;maze[5][7]=1;maze[6][1]=1;maze[6][2]=1;maze[6][3]=1;maze[6][4]=0;maze[6][5] =0;maze[6][6]=0;maze[6][7]=0;maze[7][1]=1;maze[7][2]=1;maze[7][3]=1;maze[7][4]=1;maze[7][5] =1;maze[7][6]=0;maze[7][7]=0;for(i=0;i<p+2;i++){for(j=0;j<p+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}for(i=0;i<m+2;i++)for(j=0;j<p+2;j++)mark[i][j]=0;mark[1][1]=1;stack<items> st;items tmp;tmp.x=1;tmp.y=0;tmp.dir=2;st.push(tmp);while(!st.empty()){ tmp=st.top();st.pop();i=tmp.x;j=tmp.y;d=tmp.dir;while(d<8){g=i+move[d].a;h=j+move[d].b;if(g==n&&h==q){show(st);cout<<n<<" "<<q<<endl;return 1;}if(maze[g][h]==0&&mark[g][h]==0){mark[g][h]=1;tmp.x=i;tmp.y=j;tmp.dir=d;st.push(tmp);i=g;j=h;d=0;}elsed++;}}cout<<"no path in maze"<<endl;return 0;}void main(){path(3,7);}实验四:#include<iostream.h>template<class T>class arrqueue{private:char msize;char front;char rear; T *qu;public:arrqueue(char size);~arrqueue();void clear();bool enqueue(const T item);bool dequeue(T&item);bool getfront(T&item);void print();};template<class T>arrqueue<T>::arrqueue(char size) { msize=size+1;qu=new T[msize];front=rear=0;}template<class T>arrqueue<T>::~arrqueue() {delete[] qu; }template<class T>void arrqueue<T>::clear() {front=rear; }template<class T>bool arrqueue<T>::enqueue(const T item) { if(((rear+1)%msize)==front) {cout<<"队列已满"<<endl; return false;} qu[rear]=item;rear=(rear+1)%msize;return true; }template<class T>bool arrqueue<T>::dequeue(T&item) {if(front==rear) {cout<<"队列为空"<<endl;return false;}item=qu[front];front=(front+1)%msize;return true;}template<class T>bool arrqueue<T>::getfront(T&item) {if(front==rear){cout<<"队列为空"<<endl;return false;}item=qu[front];return true;}template<class T>void arrqueue<T>::print() {cout<<qu[front]<<'\t';}void main(){arrqueue<char> a(5);char i,b[10],p,q;cout<<"队空!"<<endl;cout<<"入队:";for(i=0;i<=5;i++) {cin>>b[i];a.enqueue(b[i]);}cout<<"溢出 F"<<endl;cout<<"取队头 ";a.getfront(q);cout<<q<<endl;cout<<"元素个数 4"<<endl;/*a.dequeue(p);a.print();cout<<p<<endl;*/}实验五:#include<assert.h>#include<iostream>#include<queue>using namespace std;const int m=7;const int p=7;int grid[m+2][p+2];struct Position{int row,col;};bool FindPath(Position start,Position finish,int& PathLen,Position *& path){if(start.row==finish.row&&start.col==finish.col){PathLen=0;return true;}int NumOfNbrs=4,i,j;for(i=0;i<=m+1;i++)grid[0][i]=grid[m+1][i]=grid[i][0]=grid[i][m+1]=-1;grid[1][1]= 0;grid[1][2]= 0;grid[1][3]=-1;grid[1][4]= 0;grid[1][5]= 0;grid[1][6]= 0;grid[1][7]= 0;grid[2][1]= 0;grid[2][2]= 0;grid[2][3]=-1;grid[2][4]=-1;grid[2][5]= 0;grid[2][6]= 0;grid[2][7]= 0;grid[3][1]= 0;grid[3][2]= 0;grid[3][3]= 0;grid[3][4]= 0;grid[3][5]=-1;grid[3][6]= 0;grid[3][7]= 0;grid[4][1]= 0;grid[4][2]= 0;grid[4][3]= 0;grid[4][4]=-1;grid[4][5]=-1;grid[4][6]= 0;grid[4][7]= 0;grid[5][1]=-1;grid[5][2]= 0;grid[5][3]= 0;grid[5][4]= 0;grid[5][5]=-1;grid[5][6]= 0;grid[5][7]= 0;grid[6][1]=-1;grid[6][2]=-1;grid[6][3]=-1;grid[6][4]=0;grid[6][5]= 0;grid[6][6]= 0;grid[6][7]= 0;grid[7][1]=-1;grid[7][2]=-1;grid[7][3]=-1;grid[7][4]=0;grid[7][5]= 0;grid[7][6]= 0;grid[7][7]= 0;for(i=0;i<m+2;i++){for(j=0;j<p+2;j++)cout<<grid[i][j]<<'\t';cout<<endl;}Position offset[4];offset[0].row=0; offset[0].col=1;offset[1].row=1; offset[1].col=0;offset[2].row=0; offset[2].col=-1;offset[3].row=-1; offset[3].col=0;Position here,nbr;here.row=start.row; here.col=start.col;grid[start.row][start.col]=0;queue<Position> Q;cout<<endl;cout<<endl;cout<<"路径坐标顺序:"<<endl;do{for(i=0;i<NumOfNbrs;i++){nbr.row=here.row+offset[i].row;nbr.col=here.col+offset[i].col;if(grid[nbr.row][nbr.col]==0){grid[nbr.row][nbr.col]=grid[here.row][here.col]+1; // cout<<nbr.row<<" "<<nbr.col<<endl;if(nbr.row==finish.row&&nbr.col==finish.col){break;}Q.push(nbr);}}if(nbr.row==finish.row&&nbr.col==finish.col){break;}if(Q.empty()){cout<<"no path"<<endl;return false;}here=Q.front();Q.pop ();}while(true);PathLen=grid[finish.row][finish.col];path=new Position[PathLen];here=finish;for(j=PathLen-1;j>=0;j--){path[j]=here;for(i=0;i<NumOfNbrs;i++){nbr.row=here.row+offset[i].row;nbr.col=here.col+offset[i].col;if(grid[nbr.row][nbr.col]==j){cout<<nbr.row<<" "<<nbr.col<<endl;break;}}here=nbr;}return true;}void main(){int pl=0;Position st,fi,*p;st.row=3;st.col=2;fi.row=4;fi.col=6;FindPath(st,fi,pl,p);}五、实验结果与讨论1.如何计算顺序循环队列中元素的个数?2.如果对前面所讨论的顺序循环队列采用设置运算标志的方法来区分队列的满和空的状态,试给出对应的各运算的关键代码?3.栈的存取特点适合于什么样的应用?。
数据结构_实验三_栈和队列及其应用(可编辑
![数据结构_实验三_栈和队列及其应用(可编辑](https://img.taocdn.com/s3/m/47acafa9534de518964bcf84b9d528ea81c72f93.png)
数据结构_实验三_栈和队列及其应用(可编辑实验三:栈和队列及其应用1.实验目的:1.1掌握栈和队列的定义与基本操作。
1.2理解栈和队列的应用场景。
1.3熟悉栈和队列在计算机程序设计中的应用。
2.实验内容:2.1实现栈数据结构的基本操作:初始化、入栈、出栈、判断栈空、判断栈满、获取栈顶元素。
2.2实现队列数据结构的基本操作:初始化、入队、出队、判断队空、判断队满、获取队头元素。
2.3利用栈实现表达式求值。
2.4 利用队列解决Josephus问题。
3.实验步骤:3.1栈的实现:栈(Stack)是一种后进先出(LIFO)的数据结构,只能在一端进行插入和删除操作。
栈的实现可以使用数组或链表,这里以数组为例。
1)初始化栈:创建一个数组,设定一个栈指针top,初始时top值为-12)入栈操作:栈不满时,将元素插入到数组的top+1位置,然后top值加13)出栈操作:栈不空时,将数组的top位置的元素删除,然后top 值减14)判断栈空:当栈指针top为-1时,表示栈空。
5)判断栈满:当栈指针top达到数组的最大索引值时,表示栈满。
6)获取栈顶元素:栈不空时,返回数组的top位置的元素。
3.2队列的实现:队列(Queue)是一种先进先出(FIFO)的数据结构,插入操作在队尾进行,删除操作在队头进行。
队列的实现可以使用数组或链表,这里以数组为例。
1)初始化队列:创建一个数组,设定两个指针front和rear,初始时front和rear值均为-12)入队操作:队列不满时,将元素插入到数组的rear+1位置,然后rear值加13)出队操作:队列不空时,将数组的front+1位置的元素删除,然后front值加14)判断队空:当front和rear指针相等且都为-1时,表示队空。
5)判断队满:当rear指针达到数组的最大索引值时,表示队满。
6)获取队头元素:队列不空时,返回数组的front+1位置的元素。
3.3表达式求值:使用栈可以实现对表达式的求值。
栈与队列实验报告总结
![栈与队列实验报告总结](https://img.taocdn.com/s3/m/870f5ccdcd22bcd126fff705cc17552706225e76.png)
栈与队列实验报告总结实验报告总结:栈与队列一、实验目的本次实验旨在深入理解栈(Stack)和队列(Queue)这两种基本的数据结构,并掌握其基本操作。
通过实验,我们希望提高自身的编程能力和对数据结构的认识。
二、实验内容1.栈的实现:我们首先使用Python语言实现了一个简单的栈。
栈是一种后进先出(LIFO)的数据结构,支持元素的插入和删除操作。
在本次实验中,我们实现了两个基本的栈操作:push(插入元素)和pop(删除元素)。
2.队列的实现:然后,我们实现了一个简单的队列。
队列是一种先进先出(FIFO)的数据结构,支持元素的插入和删除操作。
在本次实验中,我们实现了两个基本的队列操作:enqueue(在队尾插入元素)和dequeue(从队头删除元素)。
3.栈与队列的应用:最后,我们使用所实现的栈和队列来解决一些实际问题。
例如,我们使用栈来实现一个算术表达式的求值,使用队列来实现一个简单的文本行编辑器。
三、实验过程与问题解决在实现栈和队列的过程中,我们遇到了一些问题。
例如,在实现栈的过程中,我们遇到了一个“空栈”的错误。
经过仔细检查,我们发现是因为在创建栈的过程中没有正确初始化栈的元素列表。
通过添加一个简单的初始化函数,我们解决了这个问题。
在实现队列的过程中,我们遇到了一个“队列溢出”的问题。
这是因为在实现队列时,我们没有考虑到队列的容量限制。
通过添加一个检查队列长度的条件语句,我们避免了这个问题。
四、实验总结与反思通过本次实验,我们对栈和队列这两种基本的数据结构有了更深入的理解。
我们掌握了如何使用Python语言实现这两种数据结构,并了解了它们的基本操作和实际应用。
在实现栈和队列的过程中,我们也学到了很多关于编程的技巧和方法。
例如,如何调试代码、如何设计数据结构、如何优化算法等。
这些技巧和方法将对我们今后的学习和工作产生积极的影响。
然而,在实验过程中我们也发现了一些不足之处。
例如,在实现栈和队列时,我们没有考虑到异常处理和性能优化等方面的问题。
实验三 栈和队列
![实验三 栈和队列](https://img.taocdn.com/s3/m/2d7d67c9aa00b52acfc7cac4.png)
实验报告三栈和队列一、实验目的:(1)掌握栈的基本操作的实现方法。
(2)利用栈先进后出的特点,解决一些实际问题。
(3)掌握链式队列及循环队列的基本操作算法。
(4)应用队列先进先出的特点,解决一些实际问题。
二、实验内容:1、使用一个栈,将一个十进制转换成二进制。
粘贴源程序:package Q1;public class SeqStack {public int element[];public int top;public static SeqStack p;public SeqStack(int size){this.element=new int[size];this.top=-1;}public void push(int x){this.top++;this.element[this.top]=x;}public int pop(){return this.top==-1 ? -1: (int)this.element[this.top--];}public int get(){return this.top==-1 ? -1: (int)this.element[this.top];}public static void disp(SeqStack p){int t = -2;while(t!=-1){t=p.pop();if(t!=-1)System.out.printf("%d",t);}}public static void fun(int x){int t;while(x!=1){t=x%2;x=x/2;p.push(t);}if(x==1)p.push(x);}public static void main(String args[]){p=new SeqStack(13);fun(99);disp(p);}}粘贴测试数据及运行结果:2、回文是指正读反读均相同的字符序列,如“acdca”、“dceecd”均是回文,但“book”不是回文。
数据结构栈与队列的实验报告
![数据结构栈与队列的实验报告](https://img.taocdn.com/s3/m/964453514531b90d6c85ec3a87c24028915f85ce.png)
数据结构栈与队列实验报告学院:数学与计算机学院班级:计算机科学与技术姓名:***学号:************实验三栈与队列一、实验目的:(1)熟练掌握栈和队列的结构以及这两种数据结构的特点、栈与队列的基本操作。
(2)能够在两种存储结构上实现栈的基本运算,特别注意栈满和栈空的判断条件及描述方法;(3)熟练掌握链队列和循环队列的基本运算,并特别注意队列满和队列空的判断条件和描述方法;(4)掌握栈的应用;二、实验要求:(1) 给出程序设计的基本思想、原理和算法描述。
(2) 对源程序给出注释。
(3) 记录程序的运行结果,并结合程序进行分析。
三、程序设计的基本思想、原理和算法描述:四、实验内容:1、利用栈的基本操作将一个十进制的正整数转换成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;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)return0;e=*--s->top;return e;}int stackempty(sqstack*s){if(s->top==s->base){return1;}else{return0;}}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){Push(s,n%flag);n=n/flag;}while(!stackempty(s)){e=Pop(s,e);switch(e){case10:printf("A");break;case11: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;}2、回文数判断#include<stdio.h>#include<string.h>#define MAX 50#define FALSE 0#define TURE 1//定义栈typedef struct{char elem[MAX];int top;}SeqStack;//定义循环队列typedef struct{char element[MAX];int front;int rear;}SeqQuene;//初始化栈void InitStack(SeqStack *S){S->top = -1;//构造一个空栈}//入栈int Push(SeqStack *S,char x,int cnt) {if(S->top == cnt-1)return(FALSE);S->top++;S->elem[S->top] = x;return(TURE);}//出栈int Pop(SeqStack * S,char * x){if(S->top == -1)return(FALSE);else{*x = S->elem[S->top];S->top--;return(TURE);}}//初始化队列void InitQuene(SeqQuene *Q){Q->front = Q->rear = 0;}//入队int EnterQuene(SeqQuene *Q,char x,int cnt) {if((Q->rear+1)%(cnt+1) == Q->front)return(FALSE);Q->element[Q->rear] = x;Q->rear = (Q->rear+1)%(cnt+1);return(TURE);}//出队int DeleteQuene(SeqQuene *Q,char *x,int cnt) {if(Q->front == Q->rear)return(FALSE);*x = Q->element[Q->front];Q->front = (Q->front+1)%(cnt+1);return(TURE);}//主函数void main(){int i,cnt,flag;SeqStack s;SeqQuene q;char a[MAX],b[MAX],c[MAX];flag=0;printf("请输入由*结束且小于%d的回文序列:\n",MAX); for(i = 0;i<MAX+1;i++){scanf("%c",&a[i]);if(a[i] == '*')break;}cnt = i;InitStack(&s);InitQuene(&q);for(i = 0;i<cnt;i++){EnterQuene(&q,a[i],cnt);Push(&s,a[i],cnt);}for(i = 0;i<cnt+1;i++){DeleteQuene(&q,&b[i],cnt);printf("%c",b[i]);}printf("\n");for(i = 0;i<cnt+1;i++){Pop(&s,&c[i]);printf("%c",c[i]);}printf("\n");for(i = 0;i<cnt+1;i++){if(b[i] == c[i])flag = 1;else{flag = 0;break;}}if(flag)printf("Right");elseprintf("Wrong");printf("\n"); }五、运行结果。
栈的操作(实验报告)
![栈的操作(实验报告)](https://img.taocdn.com/s3/m/1040e2b3e43a580216fc700abb68a98271feacc1.png)
(1) 熟悉栈的特点(先进后出)及栈的基本操作,如入栈、出栈等,掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现;(2) 熟悉队列的特点(先进先出)及队列的基本操作,如入队、出队等,掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。
(1) 复习课本中有关栈和队列的知识;(2) 用 C 语言完成算法和程序设计并上机调试通过;(3) 撰写实验报告,给出算法思路或者流程图和具体实现(源程序)、算法分析结果(包括时间复杂度、空间复杂度以及算法优化设想)、输入数据及程序运行结果 (必要时给出多种可能的输入数据和运行结果)。
编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)初始化顺序栈(2)插入元素(3)删除栈顶元素(4)取栈顶元素(5)遍历顺序栈(6)置空顺序栈栈的顺序存储结构简称为顺序栈,它是运算受限的顺序表。
对于顺序栈,入栈时,首先判断栈是否为满,栈满的条件为:p->top= =MAXNUM- 1,栈满时,不能入栈; 否则浮现空间溢出,引起错误,这种现象称为上溢。
出栈和读栈顶元素操作,先判栈是否为空,为空时不能操作,否则产生错误。
通常栈空作为一种控制转移的条件。
(1)顺序栈中元素用向量存放(2)栈底位置是固定不变的,可设置在向量两端的任意一个端点(3) 栈顶位置是随着进栈和退栈操作而变化的,用一个整型量top(通常称top 为栈顶指针) 来指示当前栈顶位置#include<stdio.h>#include<stdlib.h>#define MAXNUM 20#define ElemType int/*定义顺序栈的存储结构*/ typedef struct{ ElemType stack[MAXNUM];int top;}SqStack;/*初始化顺序栈*/void InitStack(SqStack *p){ } if(!p)printf("Eorror"); p->top=- 1;/*入栈*/void Push(SqStack *p,ElemType x){ if(p->top<MAXNUM- 1){ p->top=p->top+1;p->stack[p->top]=x;}elseprintf("Overflow!\n");}/*出栈*/ElemType Pop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];printf("以前的栈顶数据元素%d 已经被删除!\n",p->stack[p->top]);p->top=p->top- 1;return(x);}else{ printf("Underflow!\n");return(0);}}/*获取栈顶元素*/ElemType GetTop(SqStack *p){ ElemType x;if(p->top!=0){ x=p->stack[p->top];return(x);}else{ printf("Underflow!\n");return(0);}}/*遍历顺序栈*/void OutStack(SqStack *p){ int i;printf("\n");if(p->top<0)printf("这是一个空栈!");printf("\n");for(i=p->top;i>=0;i--)printf("第%d 个数据元素是:%6d\n",i,p->stack[i]); }/*置空顺序栈*/void setEmpty(SqStack *p){p->top= - 1;}/*主函数*/main(){ SqStack *q;int y,cord;ElemType a;do{printf("\n");printf("第一次使用必须初始化!\n");printf("\n");printf("\n 主菜单\n");printf("\n 1 初始化顺序栈\n");printf("\n 2 插入一个元素\n");printf("\n 3 删除栈顶元素\n");printf("\n 4 取栈顶元素\n");printf("\n 5 置空顺序栈\n");printf("\n 6 结束程序运行\n");printf("\n--------------------------------\n");printf("请输入您的选择( 1, 2, 3, 4, 5,6)");scanf("%d",&cord);printf("\n");switch(cord){ case 1:{ q=(SqStack*)malloc(sizeof(SqStack));InitStack(q);OutStack(q);}break;case 2:{ printf("请输入要插入的数据元素:a=");scanf("%d",&a);Push(q,a);OutStack(q);}break;case 3:{ Pop(q);OutStack(q);}break;case 4:{ y=GetTop(q);printf("\n 栈顶元素为:%d\n",y);OutStack(q);}break;case 5:{ setEmpty(q);printf("\n 顺序栈被置空!\n");OutStack(q);}break;case 6:exit(0);}}while (cord<=6);}编写一个程序实现链栈的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)初始化链栈(2)链栈置空(3)入栈(4)出栈(5)取栈顶元素(6)遍历链栈分析:链栈是没有附加头结点的运算受限的单链表。
数据结构栈和队列实验报告
![数据结构栈和队列实验报告](https://img.taocdn.com/s3/m/9d3ecbdf82d049649b6648d7c1c708a1284a0ad8.png)
数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。
通过编程实现栈和队列的相关操作,加深对其特性的认识,并能够运用栈和队列解决实际问题。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验原理(一)栈栈(Stack)是一种特殊的线性表,其操作遵循“后进先出”(Last In First Out,LIFO)的原则。
可以将栈想象成一个只有一端开口的容器,元素只能从开口端进出。
入栈操作(Push)将元素添加到栈顶,出栈操作(Pop)则从栈顶移除元素。
(二)队列队列(Queue)也是一种线性表,但其操作遵循“先进先出”(FirstIn First Out,FIFO)的原则。
队列就像是排队买票的队伍,先到的人先接受服务。
入队操作(Enqueue)将元素添加到队列的末尾,出队操作(Dequeue)则从队列的头部移除元素。
四、实验内容(一)栈的实现与操作1、定义一个栈的数据结构,包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。
2、实现入栈(Push)操作,当栈未满时,将元素添加到栈顶,并更新栈顶指针。
3、实现出栈(Pop)操作,当栈不为空时,取出栈顶元素,并更新栈顶指针。
4、实现获取栈顶元素(Top)操作,返回栈顶元素但不进行出栈操作。
5、实现判断栈是否为空(IsEmpty)和判断栈是否已满(IsFull)的操作。
(二)队列的实现与操作1、定义一个队列的数据结构,包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。
2、实现入队(Enqueue)操作,当队列未满时,将元素添加到队尾,并更新队尾指针。
3、实现出队(Dequeue)操作,当队列不为空时,取出队头元素,并更新队头指针。
4、实现获取队头元素(Front)操作,返回队头元素但不进行出队操作。
5、实现判断队列是否为空(IsEmpty)和判断队列是否已满(IsFull)的操作。
数据结构栈和队列实验报告
![数据结构栈和队列实验报告](https://img.taocdn.com/s3/m/be39622a54270722192e453610661ed9ad515528.png)
数据结构栈和队列实验报告数据结构栈和队列实验报告1.引言本实验旨在通过设计和实现栈和队列的数据结构,掌握栈和队列的基本操作,并进一步加深对数据结构的理解和应用。
2.实验目的本实验的主要目标包括:________●掌握栈和队列的数据结构实现。
●熟悉栈和队列的基本操作:________入栈、出栈、入队、出队。
●理解栈和队列的应用场景,并能够灵活运用。
3.实验原理3.1 栈栈是一种特殊的数据结构,它采用“后进先出”的方式对元素进行操作。
栈的主要操作包括入栈和出栈,入栈将元素压入栈顶,出栈将栈顶元素弹出。
3.2 队列队列也是一种特殊的数据结构,它采用“先进先出”的方式对元素进行操作。
队列的主要操作包括入队和出队,入队将元素放入队列尾部,出队将队列头部的元素移除。
4.实验过程4.1 栈的实现a. 定义栈的数据结构在实现栈之前,首先要定义栈的数据结构,包括数据存储结构和相关操作方法。
b. 定义入栈操作入栈操作将元素压入栈顶。
c. 定义出栈操作出栈操作将栈顶元素弹出。
4.2 队列的实现a. 定义队列的数据结构在实现队列之前,首先要定义队列的数据结构,包括数据存储结构和相关操作方法。
b. 定义入队操作入队操作将元素放入队列尾部。
c. 定义出队操作出队操作将队列头部的元素移除。
5.实验结果与分析将栈和队列的数据结构实现后,可以进行测试和验证。
通过将不同类型的元素入栈和入队,然后再进行出栈和出队操作,最后检查栈和队列的状态,验证其正确性。
6.实验总结本实验通过设计和实现栈和队列的数据结构,掌握了栈和队列的基本操作。
并通过对栈和队列的应用,加深了对数据结构的理解和应用。
附件:________无法律名词及注释:________无。
栈队列及其应用实验报告
![栈队列及其应用实验报告](https://img.taocdn.com/s3/m/ff45bb8d81eb6294dd88d0d233d4b14e85243ee7.png)
一、实验目的1. 理解栈和队列的基本概念、特点及逻辑结构。
2. 掌握栈和队列的存储结构,包括顺序存储结构和链式存储结构。
3. 熟练掌握栈和队列的基本操作,如入栈、出栈、入队、出队等。
4. 分析栈和队列在实际问题中的应用,提高解决实际问题的能力。
二、实验内容1. 栈和队列的定义及特点2. 栈和队列的存储结构3. 栈和队列的基本操作4. 栈和队列的实际应用案例分析三、实验过程1. 栈和队列的定义及特点栈(Stack)是一种后进先出(Last In First Out,LIFO)的数据结构,它只允许在一端进行插入和删除操作。
栈的典型应用场景有函数调用、递归算法等。
队列(Queue)是一种先进先出(First In First Out,FIFO)的数据结构,它允许在两端进行插入和删除操作。
队列的典型应用场景有打印队列、任务队列等。
2. 栈和队列的存储结构(1)顺序存储结构栈和队列的顺序存储结构使用数组来实现。
对于栈,通常使用数组的一端作为栈顶,入栈操作在栈顶进行,出栈操作也在栈顶进行。
对于队列,通常使用数组的一端作为队首,入队操作在队尾进行,出队操作在队首进行。
(2)链式存储结构栈和队列的链式存储结构使用链表来实现。
对于栈,每个元素节点包含数据和指向下一个节点的指针。
入栈操作在链表头部进行,出栈操作在链表头部进行。
对于队列,每个元素节点包含数据和指向下一个节点的指针。
入队操作在链表尾部进行,出队操作在链表头部进行。
3. 栈和队列的基本操作(1)栈的基本操作- 入栈(push):将元素添加到栈顶。
- 出栈(pop):从栈顶删除元素。
- 获取栈顶元素(peek):获取栈顶元素,但不删除它。
- 判断栈空(isEmpty):判断栈是否为空。
(2)队列的基本操作- 入队(enqueue):将元素添加到队列尾部。
- 出队(dequeue):从队列头部删除元素。
- 获取队首元素(peek):获取队首元素,但不删除它。
实验三 栈、队列、串的操作
![实验三 栈、队列、串的操作](https://img.taocdn.com/s3/m/7dee7758fe4733687f21aa0c.png)
实验类型:验证性实验要求:必修实验学时: 2学时一、实验目的:参照给定的栈类和队列类的程序样例,验证给出的栈和队列的常见算法,并结合线性表类实现有关串的操作。
二、实验要求:1、掌握栈、队列、串的特点。
掌握特殊线性表的常见算法。
2、提交实验报告,报告内容包括:目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。
三、实验内容:1. 堆栈类测试和应用问题。
要求:(1)设计一个主函数实现对顺序堆栈类和链式堆栈类代码进行测试。
测试方法为:依次把数据元素1,2,3,4,5入栈,然后出栈堆栈中的数据元素并在屏幕上显示。
(2)定义数据元素的数据类型为如下形式的结构体:设计一个包含5个数据元素的测试数据,并设计一个主函数实现依次把5个数据元素入栈,然后出栈堆栈中的数据元素并在屏幕上显示。
2. 队列类测试和应用问题。
要求:设计一个主函数对循环队列类和链式队列类代码进行测试.测试方法为:依次把1,2,3,4,5入队,然后出队中的数据元素并在屏幕上显示。
3.设计串采用顺序存储结构,编写函数实现两个串的比较Compare(S, T)。
要求比较结有大于、等于和小于三种情况。
*4. 设计算法利用栈类实现把十进制整数转换为二至九进制之间的任一进制输出。
*5. 设计串采用静态数组存储结构,编写函数实现串的替换Replace(S, start, T, V),即要求在主串S中,从位置start开始查找是否存在子串T,若主串S中存在子串T,则用子串V替换子串T,且函数返回1;若主串S中不存在子串T,则函数返回0。
并要求设计主函数进行测试。
一个测试例子为:S=”I am a student”,T=”student”,V=”teacher “。
四、实验源码1.1#include<iostream>using namespace std;const int StackSize=10;class SeqStack{public:SeqStack( ) {top=-1;}~SeqStack( ) { }void Push( int x ){ if (top== StackSize-1) throw "溢出";top++;data[top]=x;}int Pop( ){ if (top==-1) throw "溢出";int x=data[top--];return x;}int data[StackSize];int top;};int main(){SeqStack a;for(int i= 1 ; i <= 5; i++){ a.Push(i);}for( i = 0 ;i < 5; i++){ int k = 0;k = a.Pop();cout<< k << endl;}}1.2#include<iostream>#include<string>using namespace std;const int StackSize=10;typedef struct{int notask; char name[10];}DataType;class SeqStack{public:SeqStack( ) {top = -1;}~SeqStack( ) { }void Push( DataType x ){if (top== StackSize-1) throw "溢出";top++;data[top] = x;}DataType Pop( ){ if (top==-1) throw "溢出";DataType x=data[top--];return x;}DataType data[StackSize];int top;};int main(){ SeqStack a;DataType b[5];for(int i = 1 ; i <= 5; i++){cin>> b[i].name;b[i].notask = i; }for( i = 1 ; i <= 5; i++){ a.Push(b[i]);}for( i = 1 ;i <= 5; i++){DataType k ;k = a.Pop();cout<< <<" "<<k.notask << endl;}}2.#include<iostream>#include<string>using namespace std;#define T intconst int QueueSize=100;class CirQueue{public:T data[QueueSize];int front, rear;CirQueue( ) {front=rear=0;}~ CirQueue( ) { }void EnQueue(T x){ if ((rear+1) % QueueSize ==front) throw "上溢";rear=(rear+1) % QueueSize; data[rear]=x; } T GetQueue( ){if (rear==front) throw "下溢";int i=(front+1) % QueueSize;return data[i];}T DeQueue( ){if (rear==front) throw "下溢";front=(front+1) % QueueSize;return data[front]; }};int main(){CirQueue a;for(int i = 1 ; i <= 5; i++){ a.EnQueue(i);}for( i = 1 ;i <= 5; i++){ int k ;k = a.DeQueue();cout<< k<< endl;}}3.#include<iostream>#include<string>using namespace std;#define T charconst int QueueSize=100;class CirQueue{public:T data[QueueSize];int front, rear;CirQueue( ) {front=rear=0;}~ CirQueue( ) { }void EnQueue(T x){if ((rear+1) % QueueSize ==front) throw "溢出";rear=(rear+1) % QueueSize;data[rear]=x;}T GetQueue( ) {if (rear==front) throw "溢出";int i=(front+1) % QueueSize;return data[i];}T DeQueue( ){if (rear==front) throw "溢出";front=(front+1) % QueueSize;return data[front];}};int main(){CirQueue a,b;char x[100] = {0},y[100] = {0} ;cin >> x >> y;for(int i = 0 ; i < strlen(x); i++){a.EnQueue(x[i]);}for( i = 0 ; i < strlen(y); i++){b.EnQueue(y[i]);}int lenx = strlen(x),leny = strlen(y);if( lenx < leny ){puts("max is y");return 0;}if(lenx > leny ){puts("max is x");return 0;}for( i = 0 ;i < lenx; i++){char xx,yy;xx = a.DeQueue();yy = b.DeQueue();if(xx != yy){if(xx > yy){puts("max is x");return 0;}else{puts("max is y");return 0;}}}puts("x is equel to y");}五、实验结果1.11.223六、心得体会在这次实验中,我学到很多东西,加强了我的动手能力,并且培养了我的独立思考能力,我们坚持理论联系实际的思想,以实践证实理论,从实践中加深对理论知识的理解和掌握。
实验3 栈和队列
![实验3 栈和队列](https://img.taocdn.com/s3/m/4eb28e7501f69e31433294bf.png)
实验3 栈和队列一实验目的1、掌握栈和队列的概念及其特点;2、掌握栈和队列基本运算的算法并能设计程序实现;3、理解栈和队列的典型应用;二实验原理队列是运算受限的线性表,具有先进先出的特点。
队列的应用十分广泛,凡是具有先进先出特点需要排队处理的问题都可以使用队列来解决,比如操作系统中的I/O缓冲区管理,优先队列等等。
三使用仪器,材料1 计算机2 Wndows xp3 VC6.0四实验步骤模拟银行的叫号机。
在程序运行过程中使用文本菜单供用户选择,选择1则模拟储户按下叫号机取叫号纸(即入队列),选择2则模拟银行工作人员按下叫号机,请取得相应号数的储户到前台办理业务(即出队列)。
叫号机的号数从1号开始往上递增。
五实验过程原始记录1 基本数据结构描述;2 函数间的调用关系;3 用类C语言描述各个子函数的算法;附录:源程序。
#include <iostream.h>#include <process.h>#include <stdlib.h>#define OK 1#define ERROR -1#define OVERFLOW 0 typedef int qelemtype;typedef int status;typedef struct qnode{qelemtype data;struct qnode *next;}qnode,*queueptr;typedef struct{queueptr front;queueptr rear;}linkqueue;status initqueue(linkqueue &q) {q.front=q.rear=new qnode;if (!q.front)exit(OVERFLOW);q.front->next=NULL;return OK;};status enqueue(linkqueue &q) {queueptr p;p=new qnode;if(!p) exit(OVERFLOW);if(q.front==q.rear){ q.rear->data=1;}p->data=q.rear->data+1;p->next=NULL;q.rear->next=p;q.rear=p;return OK; }void gethead( linkqueue &q){ queueptr p;if(q.front->next==NULL){ cout<<"已没有客户需要办理业务"<<endl;}else{cout<<"请"<<q.front->data<<"号到前台办理业务"<<endl;p=q.front->next;q.front=p;}}void main(){ int a ;char cont='y';linkqueue q;initqueue(q);while(cont=='y'){ cout<<"请输入操作序号"<<endl;cout<<"1:取号"<<endl;cout<<"2:请取号人到前台办理业务"<<endl;cin>>a;switch(a){case 1:enqueue(q);break;case 2:gethead(q);break; }cout<<"是否继续操作?(y or n)";cin>>cont;if(cont=='y') cont='y';}}六试验结果分析将实验结果分析、实验中遇到的问题和解决问题的方法以及关于本实验项目的心得体会,写在实验报告上。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告三栈和队列班级:姓名:学号:专业:一、实验目的:(1)掌握栈的基本操作的实现方法。
(2)利用栈先进后出的特点,解决一些实际问题。
(3)掌握链式队列及循环队列的基本操作算法。
(4)应用队列先进先出的特点,解决一些实际问题。
二、实验内容:1、使用一个栈,将一个十进制转换成二进制。
粘贴源程序:package Ex3;/*** Created by 74062 on 2017/3/11.*/public class Stock<E> {private static class Node<E>{public E data;public Node next;public Node(E data,Node next){this.data = data;this.next = next;}}protected Node<E> head;protected int size;public Stock(){head = new Node<E>(null,null);size =0;}public boolean push(E element){Node<E> node = new Node<E>(element,head.next);head.next = node;size++;return true;}public E pop(){Node<E> node = head.next;if(node==null){return null;}if(node.next!=null){head.next = node.next;}else {head.next = null;}size--;return node.data;}public E top(){if(head.next!=null){return (E) head.next.data;}elsereturn null;}public String toString(){String str = new String();for(Node<E> node = head.next;node!=null;node = node.next){ str += node.data.toString()+" ";}return str;}public static void main(String[] args) {System.out.println(check("a*((b+c)"));}public static boolean check(String string){Stock<Character> stock = new Stock();char ch;for(int i=0;i<string.length();i++){ch = string.charAt(i);if(ch == '('){stock.push(ch);} else if(ch == ')'){if(stock.top()==null){return false;}elsestock.pop();}}if(stock.top() == null)return true;elsereturn false;}}package Ex3.Ex3_1;import Ex3.Stock;/*** Created by 74062 on 2017/3/11.*/public class Test {public static void main(String[] args) {Stock stock = new Stock();int x=15;for(;x!=0;x/=2){stock.push(x%2);}System.out.println(stock);}}粘贴测试数据及运行结果:2、回文是指正读反读均相同的字符序列,如“acdca”、“dceecd”均是回文,但“book”不是回文。
利用1中的基本算法,试写一个算法判定给定的字符串是否为回文。
(提示:将一半字符入栈,依次弹出与另一半逐个比较)粘贴源程序:package Ex3.Ex3_2;import Ex3.Stock;/*** Created by 74062 on 2017/3/11.*/public class Test {public static void main(String[] args) {String string1 = "acdca";String string2 = "dceecd";String string3 = "abcdef";System.out.println(check(string1));System.out.println(check(string2));System.out.println(check(string3));}public static boolean check(String string){boolean flag = true;Stock<Character> stock = new Stock();for(int i=0;i<string.length()/2;i++){stock.push(string.charAt(i));}for(int i=string.length()/2;i<string.length();i++){if(!stock.pop().equals(string.charAt(i))){flag = false;break;}}return flag;}}粘贴测试数据及运行结果:3、使用3个队列分别保留手机上最近10个“未接来电”、“已接来电”、“已拨电话”。
粘贴源程序:package Ex3;/*** Created by 74062 on 2017/3/11.*/public class Queue<E> {private Object[] elements;private int front;private int back;private int size;private Queue(){this(10);}public Queue(int length){elements = new Object[length];front = 0;back = 0;this.size = 0;}public boolean push(E element){if(size==elements.length){pop();}elements[back++] = element;if(back>=elements.length){back = 0;}size++;return true;}public E pop(){int i = front;if(front+1 == elements.length){front = 0;}size--;return (E)elements[i];}public String toString(){String string = new String();int j = back;for(int i=0;i<size;i++){string+=elements[j]+" ";if(++j==elements.length){j=0;}}return string;}public static void main(String[] args) {Queue<Integer> queue = new Queue<Integer>(5);queue.push(1);queue.push(2);queue.push(3);queue.push(4);queue.push(5);queue.push(6);queue.push(7);System.out.println(queue);}}package Ex3.Ex3_3;import Ex3.Queue;import java.util.Random;/*** Created by 74062 on 2017/3/11.*/public class Test {public static void main(String[] args) {String[] name = new String[]{"林伟健","冮君泽","张思远","李哲"}; Queue<String> weijielaidian = new Queue<String>(10);Queue<String> yijielaidian = new Queue<String>(10);Queue<String> yibodianhua = new Queue<String>(10);for(int i=0;i<15;i++){weijielaidian.push(name[Math.abs(newRandom().nextInt()%4)]);yijielaidian.push(name[Math.abs(newRandom().nextInt()%4)]);yibodianhua.push(name[Math.abs(new Random().nextInt()%4)]); }System.out.println("未接电话 "+weijielaidian);System.out.println("已接电话 "+yijielaidian);System.out.println("已拨电话 "+yibodianhua);}}粘贴测试数据及运行结果:三、心得体会:(含上机中所遇问题的解决办法,所使用到的编程技巧、创新点及编程的心得)。