实验二 栈与队列应用实验
实验二栈和队列应用
数据结构
实验题目
9.简单背包问题 问题描述 设一个背包所允许的重量是M，假设有N件物品， 物品的重量分别是Wi，可以任意挑选物品将背包装满。 实验要求 设计程序实现将给定背包装满的可能解。 1)采用栈等数据结构。 2)应用穷举法回溯策略求解。 3)尝试采用递归和非递归算法求解。
数据结构
实验题目
7.八皇后问题 问题描述 设一个8×8的棋盘里放置8个皇后，要求在每行、 每列、没斜线只允许放置1个皇后。 实验要求 设计实现所有可能解的程序。 1)采用栈等数据结构。 2)应用穷举法回溯策略求解。 3)尝试采用递归和非递归算法求解。
数据结构
实验题目
8.马踏棋盘问题 问题描述 中国象棋中的“马”走子的规则是：马走日字形。 实验要求 设计实现求象棋盘中的某一点出发踏遍棋盘所有点 的程序。 1)采用栈等数据结构。 2)应用穷举法回溯策略求解。 3)尝试求解所有出发点的可能 解。
数据结构
实验题目
3.运动员混合双打组合 问题描述 设有M个男羽毛球运动员和N个女羽毛球运动员，现 进行男女混合双打组合K轮配对。男女运动员分别编号 排队在等候队列，按顺序依次从男女运动员中各出队1 人组合配对。本轮没成功配对者等待下一轮次配对。
数据结构
实验题目
3.运动员混合双打组合 实验要求 设计程序模拟完成运动员组合配对过程。 1)采用队列等数据结构。 2)输出每轮的配对信息。
数据结构实验
LOGO
数据结构
实验二
实验题目
栈和队列应用
1.算术表达式求值 问题描述 由输入的四则算术表达式字符串，动态生成算术表 达式所对应的后缀式，通过后缀式求值并输出。
数据结构 实验题目
1.算术表达式求值 实验要求 十进制整数四则运算计算器。
实验2 栈和队列的操作
实验二栈和队列的操作一、实验目的1．熟悉栈和队列的存储结构；2．熟悉栈和队列的相关操作；3．利用栈和队列求解一些常见问题。
二、实验内容1、表达式求值任何一个算术表达式都是由操作数(operand) 、运算符(operator) 和界限符(edlimiter) 组成的。
为了简化问题．这里假设算术表达式中的操作数为单个数字表示的变量：运算符有加“ + ”、减“—”、乘“ * ”、除“／”和括号，表达式以“#”结束。
运算法则是括号优先级最高，先乘除，后加减，同级运算自左至右。
程序设计时需设置两个工作栈。
一个称为运算符栈，用OP 表示，用于存放表达式中的运算符：另一个称为操作数栈，用S 表示，用于存放操作数或运算结果。
这两个栈的初始状态均为空。
计算机从左至右扫描表达式，凡遇操作数一律进S 栈；若遇运算符，则要把它的优先数和栈顶运算符的优先数进行比较：若前者大，则该运算符进OP 栈；否则，栈顶运算符退栈、并进行计算，运算对象为S 栈顶上的两个元素，且先退栈的元素在运算量的右侧，后退栈的在运算量的左侧。
试编写一程序，先输入一个表达式，再求表达式的值。
2、数制转换假设现要编制一个满足下列要求的程序：对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数。
从计算过程可见，这八进制的各个数位产生的顺序是从低位到高位的，而打印输出的顺序，一般来说应从高位到低位，这恰好和计算过程相反。
因此，需要先保存在计算过程中得到的八进制数的各位，然后逆序输出，因为它是按“后进先出”的规律进行的，所以用栈最合适。
试编写一个程序，实现将十进制数转换成八进制数并输出。
三、主要任务1、完成算法设计和程序设计，并分析算法时间复杂度和空间复杂度；2、写出程序运行情况，写出输入数据及运行结果；3、撰写实验报告，写出算法设计小结和心得。
四、思考题1、为什么说栈是一种特殊线性表？它的操作与线性表有什么不同？2、对于数制转换算法，如果不用栈如何实现？。
实验2 - 栈和队列的应用
实验二栈和队列的应用——数值转换器
实验目的：
本实验的目的是使学生深入了解栈和队列的特征，以便在实际问题背景下灵活运用它们；同时还将巩固这两种结构的构造方法，熟练掌握顺序存储映像和链式映像中各类基本操作的实现。
实验要求：
从键盘输入一个10进制数，编程将其转换成16进制数，并输出。
要求实现下列函数：
(1) 实现链栈的各个基本操作函数；
(2) Transfer( )函数实现进制转换工作；
(3) main( )函数进行调用。
[实现提示]
输入：10进制整数
输出：16进制数（由数字0~9和字符A~F组成）
[测试数据]
由学生自己确定，注意边界数据。
程序运行结果：
程序源码：（后付纸）
实验心得体会：十进制转化为十六进制的方法选用了十进制数除以十六取余，因为最先求出来的余数是个位，然后是百位千位等，所以又用到了栈，使得计数单位最大的最先输出。
判断了如果从11到15就用A-B替换。
实验二(1)讲义-栈和队列的应用
实验2：栈和队列的应用
一、实验目的
1.掌握栈的表示与实现
2.掌握队列的表示与实现
3.掌握栈的入栈、出栈等基本操作
4.掌握队列的入队、出队等基本操作
二、实验内容
1.实现顺序栈各种基本运算的算法，具体操作要求如下：
（1）初始化栈，并判断栈是否为空；
（2）对a,b,c,d,f五个字符元素模拟进栈操作；并判断栈是否为空；
（3）取出栈顶元素；
（4）对a,b,c,d,f五个字符元素做依次出栈操作，并判断栈是否为空；
（5）释放栈。
具体效果如下：
注：若sqstack.cpp文件中的方法不合适，可以作修改。
2.实现链栈各种基本运算的算法
（1）初始化栈，并判断栈是否为空；
（2）对a,b,c,d,f五个字符元素模拟进栈操作；并判断栈是否为空；
（3）取出栈顶元素；
（4）对a,b,c,d,f五个字符元素做依次出栈操作，并判断栈是否为空；
（5）释放栈。
注：若listack.cpp文件中的方法不合适，可以作修改。
三、实验要求
1.独立完成实验程序的编写与调试；
2.实验完成后填写实验报告，学习委员按学号从小到大的顺序提交。
四、思考题
1.读入一个有限大小的整数n，然后按输入次序的相反次序输出各元素的值。
(用顺序栈
实现)
2.利用栈完成数制转换。
任意输入一个十进制数，将其转换成八进制数。
(用顺序栈实
现)。
实验二 栈和队列
实验二栈和队列本文档旨在介绍实验二的目的和背景，以及本实验的重要性。
实验二主要涉及栈和队列的相关概念和操作。
栈和队列是常用的数据结构，它们在计算机科学和软件开发中起着重要的作用。
栈是一种先进后出（Last In First Out，LIFO）的数据结构，类似于我们平常堆放书籍的行为。
队列是一种先进先出（First In First Out，FIFO）的数据结构，类似于排队等待的情景。
通过本实验，我们将研究如何使用栈和队列来解决各种问题。
掌握栈和队列的基本原理和操作，对于提高程序的效率和优化算法都具有重要意义。
同时，栈和队列的概念也是许多其他数据结构和算法的基础，理解栈和队列将有助于我们更深入地研究和应用其他数据结构和算法。
本实验将引导我们通过实际的编程练来加深对栈和队列的理解和应用。
我们将实现栈和队列的基本操作，例如入栈、出栈、入队、出队等，并通过一系列的例子和问题来巩固对这些概念的理解。
通过完成本实验，我们将掌握栈和队列的基本概念和操作，加深对其应用场景的理解和掌握，并培养解决问题的逻辑思维能力和编程实践能力。
让我们开始实验二的研究，进一步探索栈和队列的奥秘吧！本实验的目标是研究和理解栈和队列数据结构的基本概念和操作。
本实验主要涉及栈和队列的定义、基本操作及其应用。
栈的定义栈是一种具有后进先出（Last-In-First-Out，简称LIFO）特性的线性数据结构。
栈只允许在表尾（称为栈顶）进行插入和删除操作，且最后插入的元素最先删除。
栈的基本操作栈的基本操作包括：Push：将元素插入到栈顶。
Pop：删除栈顶的元素，并返回被删除的元素。
IsEmpty：判断栈是否为空。
Top：返回栈顶的元素，但不删除栈顶元素。
栈的应用栈在计算机科学中有广泛的应用，包括但不限于：函数调用（函数调用时的局部变量保存在栈中）。
表达式求值（后缀表达式计算等）。
浏览器的页面回退功能。
队列的定义队列是一种具有先进先出（First-In-First-Out，简称FIFO）特性的线性数据结构。
实验报告——栈和队列的应用
实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。
一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。
所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。
例如，a+b&b+a等等。
题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。
跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。
若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。
现要求写一算法模拟上述舞伴配对问题，并实现。
题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。
请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。
题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。
试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
题目5.利用循环链队列求解约瑟夫环问题。
请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。
选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。
栈和队列的应用实验报告
栈和队列的应用实验报告栈和队列的应用实验报告引言：栈和队列是计算机科学中常用的数据结构，它们在各种算法和应用中都有广泛的应用。
本实验报告旨在探讨栈和队列的基本概念、特性以及它们在实际应用中的具体使用。
一、栈的基本概念和特性栈是一种特殊的数据结构，它遵循“先进后出”的原则。
栈有两个基本操作：压栈（push）和弹栈（pop）。
压栈将元素添加到栈的顶部，弹栈则将栈顶元素移除。
栈还具有一个重要的特性，即它的访问方式是受限的，只能访问栈顶元素。
在实际应用中，栈可以用于实现递归算法、表达式求值、括号匹配等。
例如，在递归算法中，当函数调用自身时，需要将当前状态保存到栈中，以便在递归结束后能够恢复到正确的状态。
另外，栈还可以用于实现浏览器的“后退”功能，每次浏览新页面时，将当前页面的URL压入栈中，当用户点击“后退”按钮时，再从栈中弹出最近访问的URL。
二、队列的基本概念和特性队列是另一种常见的数据结构，它遵循“先进先出”的原则。
队列有两个基本操作：入队（enqueue）和出队（dequeue）。
入队将元素添加到队列的尾部，出队则将队列头部的元素移除。
与栈不同的是，队列可以访问头部和尾部的元素。
在实际应用中，队列经常用于任务调度、消息传递等场景。
例如，在操作系统中，任务调度器使用队列来管理待执行的任务，每当一个任务执行完毕后，从队列中取出下一个任务进行执行。
另外，消息队列也是一种常见的应用，它用于在分布式系统中传递消息，保证消息的顺序性和可靠性。
三、栈和队列在实际应用中的具体使用1. 栈的应用栈在计算机科学中有广泛的应用。
其中一个典型的应用是表达式求值。
当计算机遇到一个复杂的表达式时，需要将其转化为逆波兰表达式，然后使用栈来进行求值。
栈的特性使得它非常适合处理这种情况，可以方便地保存运算符和操作数的顺序，并按照正确的顺序进行计算。
另一个常见的应用是括号匹配。
在编程语言中，括号是一种常见的语法结构，需要保证括号的匹配性。
数据结构实验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<<"种摆放方法。
栈和队列实验报告
栈和队列实验报告引言：计算机科学中的数据结构是解决问题的关键。
栈和队列这两种常用的数据结构，无疑在许多实际应用中起着重要的作用。
本篇报告旨在探讨栈和队列的实验结果，并展示它们的实际应用。
一、栈的实验结果及应用1. 栈的实验结果在实验中，我们设计了一个基于栈的简单计算器，用于实现基本的四则运算。
通过栈的先进后出（Last In First Out）特性，我们成功实现了表达式的逆波兰表示法，并进行了正确的计算。
实验结果表明，栈作为一个非常有效的数据结构，可以很好地处理栈内数据的存储和检索。
2. 栈的应用栈在计算机科学中有许多实际应用。
其中之一是程序调用的存储方式。
在程序调用过程中，每个函数的返回地址都可以通过栈来保存和恢复。
另一个应用是浏览器的历史记录。
浏览器中每个访问网页的URL都可以通过栈来存储，以便用户能够追溯他们之前访问的网页。
二、队列的实验结果及应用1. 队列的实验结果在实验中，我们模拟了一个简单的出租车调度系统，利用队列的先进先出（First In First Out）特性实现乘客的排队和叫车。
实验结果表明，队列作为一个具有高效性和可靠性的数据结构，能够很好地处理排队问题。
2. 队列的应用队列在许多方面都有应用。
一个常见的应用是消息队列。
在网络通信中，消息队列可以用于存储和传递信息，确保按照特定的顺序进行处理。
另一个应用是操作系统的进程调度。
操作系统使用队列来管理各个进程的执行顺序，以实现公平和高效的资源分配。
三、栈和队列的比较及选择1. 效率比较栈和队列在实际应用中的效率取决于具体问题的需求。
栈的操作更简单，仅涉及栈顶元素的插入和删除，因此具有更高的执行速度。
而队列涉及到队头和队尾元素的操作，稍复杂一些。
但是，队列在某些问题中的应用更为广泛，例如调度问题和消息传递问题。
2. 如何选择在选择栈和队列时，需要根据实际问题的性质和需求进行综合考虑。
如果问题需要追溯历史记录或按照特定顺序进行处理，则应选择栈作为数据结构。
实验二--栈和队列其应用
实验二栈和队列其应用题目：利用栈的深度优化进行迷宫求解一、需求分析1、进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。
2、掌握软件设计的基本内容和设计方法，并培养学生进行规范化软件设计的能力。
3、掌握使用各种计算机资料和有关参考资料，提高学生进行程序设计的基本能力。
1、使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。
2、使学生掌握软件设计的基本内容和设计方法，并培养学生进行规范化软件设计的能力。
3、使学生掌握使用各种计算机资料和有关参考资料，提高学生进行程序设计的基本能力。
栈和队列其应用目的在于使读者深入了解栈和队列的特性，以便在实际问题背景下灵活运用他们；同时还将巩固对这两种结构的构造方法的掌握，接触较复杂问题的递归算法设计。
（1）：算术表达式转波兰表达式和逆波兰表达式（2）：栈列操作的验证（建栈、入栈、出栈、销毁栈）（3）：判断表达式中括弧是否正确配对（4）：队列元素倒置（5）：判断字符串是否回文（6）：字符串的基本操作（5个基本函数实现）二、概要设计栈和队列及其应用目的在于使读者深入了解栈和队列的特性，以便在实际问题背景下灵活运用他们；同时还将巩固对这两种结构的构造方法的掌握，接触较复杂问题的递归算法设计ADT Stack 的表示和实现#include<malloc.h>#define STACK_INIT_SIZE 30#define STACKINCREMENT 5typedef struct {char * base;char* top;int stacksize;}sqstack;void InitStack(sqstack &s) {s.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));// if(!s.base) exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;}void push(sqstack &s,char &c) {if(s.top-s.base>=s.stacksize) {s.base=(char *) realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(char));// if(!s.base) exit(OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=STACKINCREMENT;}*s.top++=c;}void pop(sqstack &s,char &c){if(!(s.top==s.base))c=*--s.top;int stackEmpty(sqstack s){if(s.base==s.top) return(1);return(0);}算术表达式转波兰表达式和逆波兰表达式#include <stdio.h>#include <ctype.h>void transform(char *str,int a[][2],int *n) {int i;*n=1;a[0][0]=1;a[0][1]='(';for (i=0;str[i];){if (isdigit(str[i])){a[*n][0]=0;a[*n][1]=0;while (isdigit(str[i])){a[*n][1]=a[*n][1]*10+str[i]-'0';i++;}}else{if (str[i]=='(') a[*n][0]=1;else if (str[i]==')') a[*n][0]=2;else if (str[i]=='*') a[*n][0]=3;else if (str[i]=='/') a[*n][0]=4;else if (str[i]=='+' || str[i]=='-'){if (i==0 || (!isdigit(str[i-1]) && str[i-1]!=')'))a[*n][0]=0;a[*n][1]=0;(*n)++;}if (str[i]=='+') a[*n][0]=5;else a[*n][0]=6;}a[*n][1]=str[i];i++;}(*n)++;}a[*n][0]=2;a[*n][1]=')';(*n)++;}void poland(int a[][2],int n,int p[][2],int *m) { int i;int stack[1000];//转化所用的栈int depth;//栈的深度depth=0;*m=0;for (i=0;i<n;i++){if (a[i][0]==0) stack[depth++]=i;else if (a[i][0]==1) stack[depth++]=i;else if (a[i][0]==2){while (a[stack[depth-1]][0]!=1){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}depth--;}else if (a[i][0]==3 || a[i][0]==4){while (a[stack[depth-1]][0]==0 || a[stack[depth-1]][0]==3 || a[stack[depth-1]][0]==4){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}stack[depth++]=i;}else if (a[i][0]==5 || a[i][0]==6){while (a[stack[depth-1]][0]!=1){depth--;p[*m][0]=a[stack[depth]][0];p[*m][1]=a[stack[depth]][1];(*m)++;}stack[depth++]=i;}}}void print_poland(int p[][2],int m) {int i;for (i=0;i<m;i++){if (p[i][0]==0) printf("%d",p[i][1]);else printf("%c",p[i][1]);}putchar('\n');}double evaluate(int p[][2],int m) {double stack[1000];//求值所用的栈int depth;//栈的深度int i;depth=0;for (i=0;i<m;i++){if (p[i][0]==0) stack[depth++]=p[i][1];else{double a,b;b=stack[--depth];a=stack[--depth];if (p[i][0]==3) stack[depth++]=a*b;else if (p[i][0]==4) stack[depth++]=a/b;else if (p[i][0]==5) stack[depth++]=a+b;else stack[depth++]=a-b;}}return stack[0];}int a[1000][2];int n;int p[1000][2];int m;main(){printf("5*(8-2)+9\n");transform("5*(8-2)+9",a,&n);poland(a,n,p,&m);print_poland(p,m);printf("The result of the expression is %lf\n",evaluate(p,m)); return;}判断表达式中括弧是否正确配对#include<iostream.h>#include"sqstack.h"void cmp(sqstack &s,char y,int &state1,int &state2){char x;pop(s,x); //cout<<x;if(s.top==s.base) state1=0;if(x==y) state2=1;else if(x!=y) state2=0;}void main() {sqstack s;InitStack(s);int state1=1,state2;int j=0,flag=1;char n,d[15];for(int i=0;i<15&& state1;i++) {cin>>n;if(int(n)==19) { flag=0;break;}else d[i]=n;char c=d[i];switch(c){case'<': push(s,c);break;case'{': push(s,c);break;case'[': push(s,c);break;case'(': push(s,c);break;case'>': cmp(s,'<',state1,state2); break;case'}': cmp(s,'{',state1,state2); break;case')': cmp(s,'(',state1,state2); break;case']': cmp(s,'[',state1,state2); break;}}if(state2==1) cout<<"good match\n";else cout<<"error match\n";}判断字符串是否回文#include<iostream.h>#include<string.h>#include"qnode.h"#include"sqstack.h"int n=0;void scan(linkqueue &q,sqstack &s){ char k;cin>>k;while(k!='#'){enqueue(q,k);push(s,k);cin>>k;n=n+1;}}void ko(linkqueue &q,sqstack &s){ char c,d;int a,i=1;for(n;n>0;n--){a=daqueue(q,c);pop(s,d);if(c!=d) i=0;}if(i==0) cout<<"no"<<endl;else cout<<"yes"<<endl;}void main(){linkqueue q;sqstack s;initqueue(q);initstack(s);scan(q,s);ko(q,s);}字符串的基本操作#include<stdio.h>#include <string.h>void main (){char s[200];char left[200],right[200];int L,i,j;int N,m=0;char cc[2];printf("Please enter the string\n");fgets(s,199,stdin);L = strlen(s);printf("string L=%d\n",L);printf("Please enter N \n");scanf("%d",&N);if (N < L){strncpy(left,s,N); left[N]='\0';strncpy(right, &s[L-N-1],N); right[N]='\0';printf("left: %s\n",left);printf("right: %s\n",right);} else {printf("left,right: %s\n",s);}printf("Please enter begin location m and N\n");scanf("%d %d",&m,&N);if (m>L) m=0;strncpy(right, &s[m],N); right[N]='\0';printf("mid: %s\n",right);printf("enter a letter:\n");scanf("%s",&cc[0]);printf("Locations: ");for (i=0;i<L;i++) if (s[i]==cc[0]) printf("%d ",i+1);printf("\n");for(i=L-1;i>=0;i--) printf("%c",s[i]);printf("\n");for (i=0;i<L;i++) if (s[i] >= 'a' && s[i] <= 'z') s[i]=s[i]-'a'+'A'; printf("%s\n",s);}栈列操作的验证#include <iostream.h>#include <stdlib.h>typedef int priority;typedef int Status;#define TRUE 1;#define FALSE 0;typedef char elemtype;/*栈元素类型,用链表连接*/ typedef struct node{elemtype chdata;struct node *next;}*pnode;/*定义栈*/typedef struct stack{pnode top;int length;}chstack;/*初始化栈*/void InitStack(stack &s){s.top=NULL; s.length=0;}/*栈不为空,出*/Status Push(stack &s,elemtype e){pnode tem;tem=new node;if(!tem)return FALSE;tem->chdata=e;tem->next=s.top;s.top=tem;s.length++;return TRUE;}/*栈不为空,入*/Status Pop(stack &s,elemtype &e){pnode del;e=s.top->chdata;del=s.top;s.top=s.top->next;delete del;s.length--;return TRUE;}/*做第一个'#'*/void Fstack(stack &s){elemtype e;e='#';if(!Push(s,e))exit(0);}/*取得栈顶元素,e带回*/bool Gettop(stack &s,elemtype &e){ if(s.length>=1) {e=s.top->chdata;return true;} return false;}/*定义优先级,返回*/priority chpri(char e){switch (e) {case '(': return 0;case ')': return 0; case '+': return 1;case '-': return 1;case '*': return 2;case '#': return -1;case '/': return 2;}}bool IsOperator(char e){switch (e) {case '(': break;case ')': break;case '+': break;case '-': break;case '*': break;case '/': break;default: return false;} return true;}/*返回a>=b为真*/bool PriCom(char a,char b){int ai;int bi;ai=chpri(a);bi=chpri(b);return (ai>=bi? true:false);}/*不包括空格,主要转换部分*/void conver(char suff[],char chconver[]){ stack s;char *p;char *psuff;char stacktop;char stackout;InitStack(s);Fstack(s);psuff=suff;p=chconver;while(p!='\0') {if(!IsOperator(*p))*psuff++=*p;else {switch (*p){ case'(': Push(s,*p); break;case')': do{ Gettop(s,stackout);*psuff++=stackout;}while(stacktop!='(');Gettop(s,stackout);*psuff++=stackout;break;default: Gettop(s,stacktop);if( PriCom(*p,stacktop ) )Push(s,*p);while( !PriCom(*p,stacktop) ){ Pop(s,stackout);*psuff++=stackout; }Push(s,*p);}//endswitch}//endelsep++; }//endwhilewhile(stackout!='#') {Gettop(s,stackout);*psuff++=stackout;}}三、详细设计任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；#include <iostream>#include <fstream>#include <conio.h>using namespace std;struct step //定义一个栈{int x,y,n; //x，y表示步子坐标，n表示步数};void change(char **maze,int hang,int lie){for(int i=0;i<hang+2;i++){for(int j=0;j<lie+2;j++)switch(maze[i][j]){case '1': maze[i][j]='#';break;case '+':case '0':case '.': maze[i][j]=' ';break;}}}void step_to_step(char **maze,step *Step,int hang,int lie,int n){ //单步输出for(int k=0;k<=n;k++){for(int i=0;i<hang+2;i++){for(int j=0;j<lie+2;j++){if(Step[k].x==i&&Step[k].y==j)cout<<"."<<" ";else cout<<maze[i][j]<<" ";}cout<<endl;}cout<<"这是第"<<k+1<<"步"<<endl<<endl;getch();}}void out(char **maze,int hang,int lie,int i,int j) //输出所走的路程{if(i==1&&j==1) //若回到原点则表明无出路{cout<<endl;cout<<"************************************************************" <<endl;cout<<"|-------------此迷宫没有出路，所走路线如下图---------------|"<<endl;cout<<"************************************************************" <<endl;}else //否则有出路{cout<<endl;cout<<"************************************************************" <<endl;cout<<"|----------------找到迷宫出路，如图所示--------------------|"<<endl;cout<<"************************************************************" <<endl;}for(i=0;i<hang+2;i++) //输出步子{for(j=0;j<lie+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}}void cure(char **maze,int hang,int lie){int i=1,j=0,n=-1;char Q;step *Step; //定义一个存储路程的栈Step=new step [hang*lie]; //事先给其分配一定的空间，[hang*lie]表示空间足够if(maze[1][1]=='1'){cout<<"555..我进不去!!!"<<endl<<endl;getch();exit(0);}else while(maze[hang][lie]!='.') //由右、下、左、上的顺序判断是否走通{ //'1'表示走不通，'+'表示已经走过但不通又回来的步子，'.'表示已经走过并通了的步子if(maze[i][j+1]!='1'&&maze[i][j+1]!='.'&&maze[i][j+1]!='+'){if(i==1&&j==0){cout<<"入口"<<endl;}elsecout<<"右"<<endl;maze[i][j+1]='.';j=j+1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i+1][j]!='1'&&maze[i+1][j]!='.'&&maze[i+1][j]!='+'){cout<<"下"<<endl;maze[i+1][j]='.';i=i+1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i][j-1]!='1'&&maze[i][j-1]!='.'&&maze[i][j-1]!='+'){cout<<"左"<<endl;maze[i][j-1]='.';j=j-1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else if(maze[i-1][j]!='1'&&maze[i-1][j]!='.'&&maze[i-1][j]!='+') {cout<<"上"<<endl;maze[i-1][j]='.';i=i-1;n++;Step[n].x=i;Step[n].y=j;cout<<i<<","<<j;}else //若走不通则返回上一步{if(i==1&&j==1) //当回到入口时，说明无通路，结束循环break;else{maze[i][j]='+'; //将走不通的点置为+n--;i=Step[n].x; //返回上一个点j=Step[n].y;cout<<"返回"<<endl<<i<<","<<j; //输出返回信息}}if(i==hang&&j==lie)cout<<"(出口)"<<" "<<"(共"<<n+1<<"步"<<")";}out(maze,hang,lie,i,j);cout<<endl<<endl<<endl;cout<<"是否单步输出(y/n):";cin>>Q;cout<<endl<<endl;if(Q=='y'){change(maze,hang,lie);step_to_step(maze,Step,hang,lie,n);}}int main(){char **maze; //定义一个迷宫，空间可动态int hang,lie,i,j;char Q;cout<<"希望手动输入还是文件读入(s:手动输入,w:文件读入):";cin>>Q;cout<<endl<<endl;if(Q=='s'){cout<<"请输入矩阵的行列"<<endl;cout<<"行数:";cin>>hang;cout<<"列数:";cin>>lie;cout<<endl;maze=new char *[hang+2]; //分配连续空间给迷宫for(i=0;i<hang+2;i++)maze[i]=new char [lie+2];cout<<"请输入迷宫，0表示通路，1表示墙"<<endl;for(i=1;i<=hang;i++)for(j=1;j<=lie;j++)cin>>maze[i][j];}else if(Q=='w'){ifstream infile("F:\\migong.txt",ios::in); //可用文件外部输入infile>>hang;infile>>lie;maze=new char *[hang+2]; //分配连续空间给迷宫for(i=0;i<hang+2;i++)maze[i]=new char [lie+2];for(i=1;i<=hang;i++)for(j=1;j<=lie;j++)infile>>maze[i][j];cout<<"文件读取成功！"<<endl;}for(i=0;i<hang+2;i++) maze[i][0]='1';for(i=0;i<lie+2;i++) maze[0][i]='1';for(i=0;i<lie+2;i++) maze[hang+1][i]='1';for(i=0;i<hang+2;i++) maze[i][lie+1]='1';cout<<endl<<endl;cout<<"********************您输入的迷宫为******************************"<<endl;cout<<"行数："<<hang<<" "<<"列数："<<lie;cout<<" "<<"入口："<<"1,1"<<" "<<"出口："<<hang<<","<<lie<<endl;for(i=0;i<hang+2;i++){for(j=0;j<lie+2;j++)cout<<maze[i][j]<<" ";cout<<endl;}cout<<endl<<endl<<"所走的步骤如下:"<<endl;cure(maze,hang,lie);cout<<endl<<endl<<endl; getch();return 0;}四、运行结果图1运行程序，可以选择输入迷宫的方式：有手动输入和文件输入两种方法可供选择。
数据结构实验报告 栈和队列
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．如果栈非空，返回栈顶元素的值，不删除。
2数据结构实验报告二(栈和队列及其应用)
实验二 栈和队列及其应用、实验目的1. 掌握栈和队列这两种抽象数据类型的特点，并能在相应的应用问题中正 确选用它们。
2. 熟练掌握栈类型的两种实现方法。
3. 熟练掌握循环队列和链队列的基本操作实现算法。
二、实验内容用队列求解迷宫问题[ 问题描述 ]以一个M*N 的长方阵表示迷宫，0和1分别表示迷宫中的通路和墙壁。
设计 一个程序， 对任意设定的迷宫， 求出一条从入口到出口的通路， 或得出没有通路 的结论。
[ 基本要求 ]实现一个以顺序存储结构的队列类型， 然后编写一个求解迷宫的非递归程序。
求得的通 路以三元组（i ，j ，pre ）的形式输出，其中：（i ，j ）指示迷宫中的一个坐标,径中上一个方块在队列中的下标。
三、源代码# include <stdio.h>{1,1,1,1,1,1,1}, {1,0,0,0,0,0,1}, {1,0,1,0,0,1,1},pre 表示本路[ 测试数据 ] 由学生任意指定。
#define M 5// #define N 5// 行数 列数 #define MaxSize 100// int mg[M+2][N+2]={// 队最多元素个数 一个迷宫 , 其四周要加上均为 1 的外框 {1,1,{1,0,1,0,0,1,1}, {1,0,1,0,1,0,1}, {1,0,0,0,0,0,1},{1,1,1,1,1,1,1} }; typedef struct {inti,j;int pre;}Box; typedef struct{Boxdata[MaxSize];int front, rear;}QuType;void mgpath1(int xi,int yi,intxe,int ye) // ->(xe,ye) { void print (QuType qu, int front );搜索路径为：（ xi ，yi ） inti,j,find=0,di; QuType qu;qu.front=qu.rear=-1; //定义顺序队qu.rear++; qu.data[qu.rear].i=xi; //(xi,yi) 进队qu.data[qu.rear].j=yi;qu.data[qu.rear].pre=-1;mg[xi][yi]=-1;while(qu.front!=qu.rear&&!find){qu.front++;i=qu.data[qu.front].i;j=qu.data[qu.front].j; if(i==xe&&j==ye){find=1;print(qu,qu.front);} for(di=0;di<4;di++) switch(di) case0 :i=qu.data[qu.front].i-1;j=qu.data[qu.front].j;break;case1:i=qu.data[qu.front].i;j=qu.data[qu.front].j+1;break;case2:i=qu.data[qu.front].i+1;j=qu.data[qu.front].j+1;break;case3:i=qu.data[qu.front].i;j=qu.data[qu.front].j-1;break;}if(mg[i][j]==0){find=1;qu.rear++;qu.data[qu.rear].i=i; qu.data[qu.rear].j=j;qu.data[qu.rear].pre=qu.front;mg[i][j]=-1;}void print (QuType qu, int front ){int k=front,j,ns=0; printf("\n");do{j=k;k=qu.data[k].pre;qu.data[j].pre=-1;}while (k!=0);printf(" 迷宫路径如下：\n");k=0;while(k<MaxSize){if(qu.data[k].pre==-1){ns++;printf("\t(%d,%d)",qu.data[k].i,qu.data[k].j);if(ns%5==0)printf("\n");}k++;} printf("\n");}void main(){ mgpath1(1,1,M,N);printf(" 迷宫所有路径如下:\n");四、测试结果：文档来源为：从网络收集整理.word 版本可编辑.欢迎下载支持.做实验首先要掌握大量的理论知识，大的困难，这就要需要我们的毅力。
北邮数据结构实验报告二_栈和队列
2009级数据结构实验报告实验名称：实验二栈和队列学生姓名：班级：班内序号：学号：日期：2010年12月18日实验要求题目四用栈做计算器。
设计一个算术四则运算表达式求值的简单计算器。
表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。
基本要求：输入中缀表达式能够转化成后缀表达式，比如输入中缀表达式“(A+B)*C”，输出“AB+C*”2、操作数使用单字母变量A、B、C等表示，操作符仅为+、-、*、/、（和）；3、能够对变量A、B、C等赋值，得出正确的计算结果2. 程序分析首先，程序要求用户输入一个符号表达式，只能包含字母、+、-、*、/ 以及）和（，之后程序会用一个TurnInfixToPostfix（）函数将表达式转化成后缀表达式存入一个栈中，转化过程借用逆波兰算法，建立一个符号栈，遍历用户输入的表达式，如果是字母，则直接输出，如果是运算符，则压入符号栈中（包括括号），在压栈的时候又需要注意，先要检查压栈前栈顶元素的优先级，如果优先级高于要压入的符号则直接压入该符号，否则要弹栈直到栈顶元素的优先级小于该元素的优先级然后才将该符号压入栈中（在压栈的时候会涉及到栈中有括号的情况，具体细节下面会说到），将转化的后缀表达式存入栈postfix，在输出的时候只要弹栈就行。
然后，要求用户逐个输入表达式中的字母的值，这时候，需要遍历当时在转化后缀表达式的时候过度容器vec_intoposfix，如果是字母则要求用户输入数值，压入用于计算的后缀表达式容器，如果是操作符则直接压入。
最后，在利用栈来计算值的时候，利用一个递归函数，就是一次弹栈，如果是操作符则先保存起来，接着继续弹栈，如果接下来的两个元素都为数字，就将这两个数字做相应的运算，然后压栈，如此反复，最后压入栈的元素就是表达式的值。
至此，程序的功能全部实现。
2.1 存储结构[内容要求]1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59页图2-92.2 关键算法分析关键算法一：将中缀表达式转化为后缀表达式VoidTurnInfixToPostfix(vector<char>&vec,stack<char>&sta,vector<char>&vecfix,stack< char>&stafix)1、 {2、int priority(-1);3、4、for (vector<char>::iterator itr=vec.begin();itr!=vec.end();itr++)5、{6、if(isLetter(*itr))7、{8、vecfix.push_back(*itr);9、}10、if (isOperator(*itr))11、{12、if(!sta.empty()) priority=getPriority(sta.top());13、else priority=-1;14、if (priority<getPriority(*itr)||priority==3&&sta.top()!=')')15、{16、sta.push(*itr);17、}18、else19、{20、if (sta.top()!=')')21、{22、while(priority>=getPriority(*itr)&&sta.top()!='(')23、{24、vecfix.push_back(sta.top());25、if (!sta.empty())26、{27、sta.pop();28、if(!sta.empty()) priority=getPriority(sta.top());29、else priority=-1;30、}31、else32、break;33、}34、sta.push(*itr);35、}36、else if(sta.top()==')')37、{38、while (sta.top()!='(')39、{40、vecfix.push_back(sta.top());41、if (!sta.empty()&&sta.top()!='(')42、{43、sta.pop();44、}45、else46、break;47、}48、}49、}50、51、52、}53、54、}55、for (vector<char>::iteratoritrfix=vecfix.end();itrfix!=vecfix.begin();--itrfix)56、stafix.push(*itrfix);57、stafix.push(*itrfix);58、}对表达式a + b * c – ( d – e) / f + g其符号栈的变化过程，红色表示未压栈的符号。
栈和队列的应用实验报告
栈和队列的应用实验报告
《栈和队列的应用实验报告》
一、实验目的
本实验旨在通过实际操作，掌握栈和队列的基本概念、操作及应用，加深对数
据结构的理解和应用能力。
二、实验内容
1. 栈的基本操作：包括入栈、出栈、获取栈顶元素等。
2. 队列的基本操作：包括入队、出队、获取队首元素等。
3. 栈和队列的应用：通过实际案例，探讨栈和队列在实际生活中的应用场景。
三、实验步骤
1. 学习栈和队列的基本概念和操作。
2. 编写栈和队列的基本操作代码，并进行调试验证。
3. 分析并实现栈和队列在实际应用中的案例，如表达式求值、迷宫问题等。
4. 进行实际应用案例的测试和验证。
四、实验结果
1. 成功实现了栈和队列的基本操作，并通过实际案例验证了其正确性和可靠性。
2. 通过栈和队列在实际应用中的案例，加深了对数据结构的理解和应用能力。
五、实验总结
通过本次实验，我深刻理解了栈和队列的基本概念和操作，并掌握了它们在实
际应用中的重要性和作用。
栈和队列作为数据结构中的重要内容，对于解决实
际问题具有重要意义，希望通过不断的实践和学习，能够更加熟练地运用栈和
队列解决实际问题，提高自己的编程能力和应用能力。
六、感想与展望
本次实验让我对栈和队列有了更深入的了解，也让我对数据结构有了更加深刻的认识。
我将继续学习和探索更多的数据结构知识，提高自己的编程能力和解决问题的能力，为将来的学习和工作打下坚实的基础。
同时，我也希望能够将所学知识应用到实际工程中，为社会做出更大的贡献。
实验2_栈与队列的应用
实验二：栈与队列的应用学时：4学时实验目的：掌握栈与队列的基本结构和操作方法，并能利用其解决实际问题。
实验内容： (任选一题，有能力的同学可以两题都做)一、输入一个表达式(4+2*4#),利用栈求表达式的值。
（只对整数求值，目前只考虑操作数为个位数的情况，即24+34*34这种情况不考虑）提示：1，先实现栈的基本操作：初始化，入栈，出栈等。
2，首先将一个中缀式变成后缀式，然后，对后缀式求值。
3，可用顺序栈或者链栈实现。
二、编写一个程序，反映病人到医院看病排队看医生的情况，在病人排队过程中，主要重复两件事：（1）病人到达诊室，将病历交给护士，排到等待队列中侯诊（2）护士从等待队列中取出下一位病人的病历，改病人进入诊室就诊要求：模拟病人等待就诊这一过程，程序采用菜单式，其选项和功能说明如下：（1）排队——输入排队病人的病历号，加入到病人排队队列中（2）就诊——病人排队队列中最前面的病人就诊，将其从队列中删除（3）查看排队——从队首到队尾理出所有的排队病人的病历号（4）不在排队，余下依次就诊——从队首到队尾列出所有的排队病人的病历号，并退出运行（5）下班——退出运行（6）上班——初始化排队队列。
提示：1，先实现队列的基本操作：初始化，入队，出队等。
2，在main（）程序中，模拟病人看病这个过程。
给出菜单选择，进行相应的操作3，可用顺序队列或者链队列实现。
可参考如下代码：顺序栈的实现ch32_sstack.c#include "stdio.h"#define StackSize 100typedef int ElemType;typedef struct {ElemType elem[StackSize];int top;}SqStack;InitStack(SqStack *pS){pS->top=0; /* top指向栈顶的上一个元素*/}int Push(SqStack *pS,ElemType e){if (pS->top==StackSize-1) /* 栈满*/return 0;pS->elem[pS->top]=e;pS->top=pS->top+1;return 1;}int Pop(SqStack *pS,ElemType* pe){if (pS->top==0) /* 栈空*/return 0;pS->top = pS->top - 1;*pe = pS->elem[pS->top];return 1;}main(){SqStack S;ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}链栈的实现ch3_lstack.c #include "stdio.h"/* 数据元素的类型*/typedef int ElemType;/* 节点的类型（包括头节点）*/typedef struct Node{ElemType elem;struct Node *next;}SNode;/* 初始化，头节点*/InitStack(SNode* pS){pS->next=NULL;}/* 入栈：在头节点之后插入一个新节点*/Push(SNode* pS,ElemType e){SNode* node;node = (SNode*)malloc(sizeof(SNode));node->elem = e;node->next = pS->next;pS->next = node;}int Pop(SNode* pS,ElemType* pe){SNode* node;if (pS->next==NULL){return 0;}*pe = pS->next->elem;node=pS->next;pS->next=node->next;free(node);return 1;}main(){SNode S; ElemType e;int N;InitStack(&S);N=1348;while(N){e = N % 8;Push(&S,e);N = N/8;}while(Pop(&S,&e)){printf("%d",e);}getch();}队列的顺序实现（循环队列）ch3_squeue.c/*队列的顺序实现（循环队列）author: Shirleydate: 2011.3*/#define MaxSize 100typedef int ElemType;typedef struct {ElemType elem[MaxSize];int front,rear;}SqQueue;InitQueue(SqQueue* pQ){pQ->front=pQ->rear=0;}int EnQueue(SqQueue* pQ,ElemType e){if ((pQ->rear+1)%MaxSize == pQ->front) /* 队满*/ return 0;pQ->elem[pQ->rear] = e;pQ->rear = (pQ->rear+1)%MaxSize;return 1;}int DeQueue(SqQueue* pQ,ElemType* pe){if (pQ->rear == pQ->front) /* 队空*/return 0;*pe = pQ->elem[pQ->front];pQ->front = (pQ->front+1)%MaxSize;return 1;}main(){SqQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}getch();}队列的链式实现ch3_lqueue.c /*队列的链式实现author: Shirleydate: 2011.3*/#include "stdio.h"#define MaxSize 100typedef int ElemType;typedef struct QNode{ElemType elem;struct QNode * next;}QNode;typedef struct {QNode* front;QNode* rear;}LinkQueue;InitQueue(LinkQueue* pQ){QNode* node;node=(QNode*)malloc(sizeof(QNode)); /*分配一个头节点*/ node->next = NULL;pQ->front=pQ->rear=node;}int EnQueue(LinkQueue* pQ,ElemType e){QNode* node;node=(QNode*)malloc(sizeof(QNode));node->elem = e;node->next = NULL;pQ->rear->next = node;pQ->rear = node;return 1;}int DeQueue(LinkQueue* pQ,ElemType* pe){QNode* node;if (pQ->rear == pQ->front) /* 队空*/return 0;node = pQ->front->next;*pe = node->elem;pQ->front->next = node->next;/* 注意有个头节点，当最后一个元素出队时，记得更新尾指针*/ if (pQ->rear==node)pQ->rear=pQ->front;free(node);return 1;}DestoryQueue(LinkQueue* pQ){while(pQ->front){pQ->rear=pQ->front->next;free(pQ->front);pQ->front = pQ->rear;}}main(){LinkQueue Q;ElemType e;InitQueue(&Q);e=2;EnQueue(&Q,e);e=5;EnQueue(&Q,e);e=3;EnQueue(&Q,e);while(DeQueue(&Q,&e)){printf("\n%d",e);}DestoryQueue(&Q);getch();}。
实验二：栈与队列应用
实验报告
算法描述：可以用自然语言、伪代码或流程图等方式
将十进制数N转换为r进制得数，其转换方法采用逐次除以基数r取余法，直至商等于0为止。
采用这种方法，转换所得的r禁制数将按低位到高位的顺序产生，而通常数的输出形式是从高位到低位进行的，恰好与计算机过程相反，因此过程转换过程中每得到以为r进制数则进栈保存，转换完毕后依次出栈，这样正好是转换结果。
算法的实现和测试结果：包括算法运行时的输入、输出，实验中出现的问题及解决办法等
2．算术表达式求值算法
数据结构定义
采用栈作为数据结构进行设计。
算法设计思路简介
本程序主要分为六个模块（主要算法模块图见图1.1）：栈的顺序存储模块、进栈模块、出栈模块、运算模块、判断优先级模块、处理表达式主体模块。
栈的顺序存储模块：分别建立两个栈，第一个用来存储运算符，第二个是用来存储数字。
算法描述：可以用自然语言、伪代码或流程图等方式
算法的实现和测试结果：包括算法运行时的输入、输出，实验中出现的问题及解决办法等。
栈和队列的基本操作及其应用(回文判断)
[测试数据]
由学生任意指定。
【程序代码】
#include<stdio.h>
#include<string.h>
int huiwen(char*s)
{
int i,j;
j=strlen(s) - 1;//不能为strlen(s),那样调用s[j]会下标越限
void main()
{
char s[80];
gets(s);
if(huiwen(s)==1)
printf("yes!");
else
printf("no!");
}
【运行结果】
二、实验内容
本次实验提供2个题目，每个题目都标有难度系数，*越多难度越大，学生可以根据自己的情况任选一个！
题目一：回文判断（*）
[问题描述]
对于一个从键盘输入的字符串，判断其是否为回文。回文即正反序相同。如“abba”是回文，而“abab”不是回文。
[基本要求]
（1）数据从键盘读入；
（2）输出要判断的字符串；
for(i=0;i<j;i++)
{
if(s[i]==s[j])
j--;
else
break;//不符合回文条件
}
if(i>=j)//当i==j时，s[i] = s[j]且两端都能组成回文，当i>j时，i必等于j+1,也为回文，i<j只有当不是回文break时产生。
retu本操作及其应用一实验目的1掌握栈和队列的顺序存储结构和链式存储结构以便在实际中灵活应用
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构（A）
实验二 栈与队列应用
石家庄铁道学院计算机与信息工程 分院 刘立嘉
数据结构
石家庄铁道学院 刘立嘉
实验目的
掌握栈和队列的特点、逻辑结构和物理 实现； 掌握实际问题中栈的应用； 掌握实际问题中队列的应用；
2
数据结构
石家庄铁道学院 刘立嘉
实验内容
马踏棋盘（参见数据结构习题集）或N 皇后问题（二选一） 国际象棋中的皇后威力无穷，可以吃掉 水平方向、垂直方向、斜线方向的其他 棋子。现有一个N*N的棋盘，在棋上放 置N 个皇后，要使它们和平共处，请给 出放置方案。 算术表达式求值演示 参见数据结构习题集。附加功能要求： 能刘立嘉
实验报告的内容
参见实验指导书!
4