堆栈应用括号匹配实验
栈的实验报告结论(3篇)
第1篇一、实验目的1. 理解栈的基本概念和操作；2. 掌握栈的顺序存储和链式存储实现方法；3. 熟悉栈在程序设计中的应用。
二、实验内容1. 栈的顺序存储结构实现；2. 栈的链式存储结构实现；3. 栈的基本操作（入栈、出栈、判空、求栈顶元素）；4. 栈在程序设计中的应用。
三、实验方法1. 采用C语言进行编程实现；2. 对实验内容进行逐步分析，编写相应的函数和程序代码；3. 通过运行程序验证实验结果。
四、实验步骤1. 实现栈的顺序存储结构；（1）定义栈的结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证顺序存储结构的栈操作。
2. 实现栈的链式存储结构；（1）定义栈的节点结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证链式存储结构的栈操作。
3. 栈在程序设计中的应用；（1）实现一个简单的四则运算器，使用栈进行运算符和操作数的存储；（2）实现一个逆序输出字符串的程序，使用栈进行字符的存储和输出；（3）编写测试程序，验证栈在程序设计中的应用。
五、实验结果与分析1. 顺序存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，栈顶元素增加；（2）出栈操作：在栈非空的情况下，出栈操作成功，栈顶元素减少；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。
2. 链式存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，链表头指针指向新节点；（2）出栈操作：在栈非空的情况下，出栈操作成功，链表头指针指向下一个节点；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。
3. 栈在程序设计中的应用实验结果：（1）四则运算器：成功实现加、减、乘、除运算，并输出结果；（2）逆序输出字符串：成功将字符串逆序输出；（3）测试程序：验证了栈在程序设计中的应用。
栈的实现及应用实验原理
栈的实现及应用实验原理一、栈的实现栈是一种先进后出（FILO）的数据结构，它可以被用来实现许多算法和数据结构。
栈可以使用数组或链表来实现。
在这里，我将介绍一下基于数组的栈的实现原理。
1.1 基于数组的栈基于数组的栈实现非常简单，可以使用一个固定大小的数组来存储栈中的元素。
栈具有两个基本操作：压入（push）和弹出（pop）。
在基于数组的栈中，当一个元素压入栈时，它被放入数组的末尾（栈顶），而当一个元素弹出栈时，数组的末尾元素被移除，并返回给调用者。
1.2 实现细节在基于数组的栈中，我们需要跟踪栈顶元素的位置，通常通过一个指示栈顶索引的变量来实现。
当一个元素被压入栈时，我们将它放入数组的栈顶位置，并将栈顶索引加一；当一个元素被弹出栈时，我们将栈顶索引减一，并返回数组中当前栈顶索引位置的元素。
为了避免栈的溢出（stack overflow）或者栈的下溢（stack underflow），我们还需要处理一些边界情况。
例如，在压入元素前，我们需要检查是否数组已满；在弹出元素前，我们需要检查栈中是否有元素。
这些细节需要涵盖在栈的实现中，以保证栈的正确性和健壮性。
1.3 时间复杂度基于数组的栈的时间复杂度非常简单：压入和弹出元素的时间复杂度均为O(1)，因为它们只涉及数组末尾的操作。
对于数组的访问（取得栈顶元素）的时间复杂度也为O(1)。
二、栈的应用栈是一种非常重要的数据结构，它在编程中有着广泛的应用。
以下是栈的一些应用实例：2.1 逆波兰表达式逆波兰表达式是一种不包含括号的数学表达式，它使用操作符在操作数之间排列。
逆波兰表达式的计算可以通过栈来实现。
具体地，当遇到一个操作数时，将其压入栈中；当遇到一个操作符时，弹出栈顶的两个元素，并进行相应的计算，将结果压入栈中。
这样，最终栈中剩下的元素就是逆波兰表达式的计算结果。
2.2 括号匹配在编程中，括号匹配是一个非常常见的问题。
给定一个包含括号的字符串，我们需要判断其中的括号是否匹配。
解决括号匹配问题的思路方法和流程
解决括号匹配问题的思路方法和流程解决括号匹配问题的思路方法和流程引言括号匹配问题是编程中常见的问题，特别是在字符串处理和栈的应用中。
本文介绍了解决括号匹配问题的思路方法和流程，帮助读者更好地理解和解决这一问题。
思路方法和流程1.定义括号匹配问题：括号匹配问题指在一个字符串中判断左右括号是否合法匹配的问题。
2.基本思路：括号匹配问题可以使用栈的数据结构来解决。
我们可以遍历字符串，遇到左括号则入栈，遇到右括号则与栈顶元素比较，如果匹配则栈顶元素出栈，否则说明左右括号不匹配。
3.算法流程：–创建一个空栈，用于存储左括号。
–遍历字符串中的每一个字符。
–如果当前字符是左括号，则将其入栈。
–如果当前字符是右括号，则与栈顶元素比较。
–如果栈为空或栈顶元素与当前字符不匹配，则说明左右括号不匹配，返回 false。
–如果栈顶元素与当前字符匹配，则将栈顶元素出栈。
–遍历完字符串后，如果栈为空，则说明所有左右括号都匹配，返回 true；否则，返回 false。
4.代码示例（使用Python实现）：def is_valid_parentheses(s: str) -> bool: stack = []for c in s:if c == "(" or c == "{" or c == "[":(c)else:if not stack:return Falseif c == ")" and stack[-1] != "(":return Falseif c == "}" and stack[-1] != "{":return Falseif c == "]" and stack[-1] != "[":return False()return not stack5.复杂度分析：–时间复杂度：遍历字符串的时间复杂度为 O(n)，其中 n 为字符串的长度。
利用顺序栈解决括号匹配问题（c++）--数据结构
利⽤顺序栈解决括号匹配问题（c++）--数据结构题⽬：7-1 括号匹配（30 分)给定⼀串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程检查这⼀串字符中的( ) ,[ ],{ }是否匹配。
输⼊格式:输⼊在⼀⾏中给出⼀⾏字符串，不超过100个字符，可能包括括号、数字、字母、标点符号、空格。
输出格式:如果括号配对，输出yes，否则输出no。
输⼊样例1:sin(10+20)输出样例1:yes输⼊样例2:{[}]输出样例2:no分析：通过详读题⽬以及例题我们可以知道：程序会读⼊随机输⼊的⼀串字符串，⽽当只有 '('和')' 、'['和']' 、 '{'和'}'相匹配的时候输出“yes”，其他情况都会输出“no”。
这时候我们可以采⽤顺序栈的结构来解决这⼀个问题：将所有的左括号（即" ( 、[ 、{ "）存⼊栈中，遇到右括号（即" )、]、}"）时出栈，再判断两者是否匹配。
代码：#include<iostream>#include<string.h>using namespace std;//定义栈#define max_size 200//栈的最⼤容量typedef char datatype;typedef struct{datatype zhan[max_size];int top;//栈顶}stack;//栈的初始化void initial(stack &st){st.top = 0;}//类型为datatype的x⼊栈void push(stack &st, datatype x){//当栈顶和max_size相等时，栈满if(st.top == max_size){// cout<<"This stack has already full!";cout<<"no";exit(0);}else{st.zhan[st.top] = x;st.top++;}}//出栈char pop(stack &st){if(st.top == 0){// cout<<"This stack is empty!";cout<<"no";exit(0);}else{st.top--;return st.zhan[st.top];}}int main(){stack s;initial(s);/*输⼊字符串，并将字符串放到字符数组中，实现能够逐个扫描字符串中的字符，并且不跳过空格符*/string str;getline(cin, str);char ch[200]={'\0'};strcpy(ch,str.c_str());//flag标志状态 1为括号匹配，0为不匹配int flag=1;int i;for(i=0; ch[i]!='\0'; i++){//元素若为{，(，[则⼊栈if((ch[i] == '{' )|| (ch[i] =='[') || (ch[i] =='(')){push(s, ch[i]);}//元素若为}，)，]则出栈赋值给aelse if((ch[i] == '}') || (ch[i] ==']') || (ch[i] ==')')){char a;a = pop(s);//若a与ch[i]匹配，进⾏下⼀个字符扫描if((a == '{' && ch[i] == '}') || (a == '(' && ch[i] == ')') || (a == '[' && ch[i] == ']')){ continue;}else flag = 0;}}if(s.top != 0){ //当左括号多出没有与右括号匹配的时候（如：" {() "）flag = 0}if(flag == 0){cout<<"no";}else cout<<"yes";return0;}编程过程中遇到的问题：1. 在对字符串进⾏⼊栈操作时s.top（栈顶）的数值不增加，总为1错误代码如下：运⾏结果如下：这段代码对于初学者来说看上去逻辑和操作过程似乎都没有问题，同时也困扰了我许久，在参考了《数据结构（c语⾔版）》李云清等编著的教程后，我发现我犯了⼀个致命的低级错误：编程push函数的时候，传⼊的参数为 stack st ，是不具有返回的功能，也就意味着在 push 函数中对于 st.top++ 这个操作没有更改主函数中st.top的数值。
数据结构实验三栈和队列的应用
数据结构实验三栈和队列的应用数据结构实验三：栈和队列的应用在计算机科学领域中，数据结构是组织和存储数据的重要方式，而栈和队列作为两种常见的数据结构，具有广泛的应用场景。
本次实验旨在深入探讨栈和队列在实际问题中的应用，加深对它们特性和操作的理解。
一、栈的应用栈是一种“后进先出”（Last In First Out，LIFO）的数据结构。
这意味着最后进入栈的元素将首先被取出。
1、表达式求值在算术表达式的求值过程中，栈发挥着重要作用。
例如，对于表达式“2 ＋ 3 4”，我们可以通过将操作数压入栈，操作符按照优先级进行处理，实现表达式的正确求值。
当遇到数字时，将其压入操作数栈；遇到操作符时，从操作数栈中弹出相应数量的操作数进行计算，将结果压回操作数栈。
最终，操作数栈中的唯一值就是表达式的结果。
2、括号匹配在程序代码中，检查括号是否匹配是常见的任务。
可以使用栈来实现。
遍历输入的字符串，当遇到左括号时，将其压入栈；当遇到右括号时，弹出栈顶元素，如果弹出的左括号与当前右括号类型匹配，则继续，否则表示括号不匹配。
3、函数调用和递归在程序执行过程中，函数的调用和递归都依赖于栈。
当调用一个函数时，当前的执行环境（包括局部变量、返回地址等）被压入栈中。
当函数返回时，从栈中弹出之前保存的环境，继续之前的执行。
递归函数的执行也是通过栈来实现的，每次递归调用都会在栈中保存当前的状态，直到递归结束，依次从栈中恢复状态。
二、队列的应用队列是一种“先进先出”（First In First Out，FIFO）的数据结构。
1、排队系统在现实生活中的各种排队场景，如银行排队、餐厅叫号等，可以用队列来模拟。
新到达的顾客加入队列尾部，服务完成的顾客从队列头部离开。
通过这种方式，保证了先来的顾客先得到服务，体现了公平性。
2、广度优先搜索在图的遍历算法中，广度优先搜索（BreadthFirst Search，BFS）常使用队列。
从起始节点开始，将其放入队列。
栈和队列基本操作实验报告
实验二堆栈和队列基本操作的编程实现
【实验目的】
堆栈和队列基本操作的编程实现
要求：
堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部实现。
也鼓励学生利用基本操作进行一些应用的程序设计。
【实验性质】
验证性实验（学时数：2H）
【实验内容】
内容：
把堆栈和队列的顺序存储（环队）和链表存储的数据进队、出队等运算其中一部分进行程序实现。
可以实验一的结果自己实现数据输入、数据显示的函数。
利用基本功能实现各类应用，如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。
【实验分析、说明过程】
【思考问题】
链表存储：通过链表的存储可以实现链表中任意位置的插入元素，删除任意元素，可以实现无序进出。
2.还会有数据移动吗？为什么？
答:栈的顺序存储不会有数据移动，移动的只是指向该数据地址的指针。
3.栈的主要特点是什么？队列呢？
【实验小结】 (总结本次实验的重难点及心得、体会、收获)
【附录-实验代码】。
括号匹配问题 栈c语言
括号匹配问题栈c语言括号匹配问题是计算机科学领域中十分重要的一个主题，它可以在处理括号匹配问题中发挥作用。
括号匹配问题被广泛应用在计算机科学领域中，比如编译器，语法分析等领域。
要解决括号匹配问题，常用的方法之一就是使用栈数据结构来解决。
栈是一种非常简单而又十分有效的数据结构，它的特点是“后进先出”（LIFO），即一个元素最先被放入栈中，在任何情况下都会最后被取出。
因此，使用栈来解决括号匹配问题，是一种非常有效的方法。
那么，栈的c语言实现是怎样的呢？在c语言中，可以使用结构体来实现栈。
栈的结构体由以下三部分组成：Top指针，MaxSize和Data，其中Top指针表示栈顶元素的位置；MaxSize表示栈的最大存储容量；Data是存储栈内元素的数组。
栈的实现需要定义一些函数，比如push()和pop()函数，用于入栈和出栈的操作；isEmpty()函数，用于判断栈是否为空；isFull()函数，用于判断栈是否已满，以及压栈和出栈元素到栈顶等等。
接下来就是使用栈来解决括号匹配问题了。
首先，要判断输入的字符串中括号是否匹配，可以使用计数法来判断。
例如，如果字符串中出现“（”，就把计数器加1，若出现“）”，就把计数器减1；最后如果计数器为0，则说明字符串中括号是匹配的。
如果字符串的括号是匹配的，则可以使用栈来检验字符串中括号的匹配情况。
从字符串的第一个字符开始遍历，如果当前字符为“（”，则压进栈；如果当前字符为“）”，则出栈一个“（”，表示当前字符与栈中的“（”匹配；如果栈中没有“（”，则说明当前字符串中括号不匹配。
例如，“（（）（））”这个字符串，经过上述操作，最后栈空，说明括号是完全匹配的。
而“（（））（）”这个字符串，之后经过操作，栈中会剩一个“（”，说明括号不匹配。
总结以上就是括号匹配问题栈的c语言实现的内容，括号匹配问题是计算机领域中一个常见的问题，栈的c语言实现就是使用结构体定义栈，然后定义一些函数，来实现栈的入栈和出栈操作，最后通过计数法或者栈结构，来判断字符串中括号是否完全匹配。
编写一个括号匹配的检验的程序实习报告
编写一个括号匹配的检验的程序实习报告在计算机科学领域，括号匹配是一个常见的问题。
括号匹配指的是在一个字符串中，所有的括号都必须正确地成对出现。
如果所有的括号都能正确地匹配，那么该字符串是合法的；否则，该字符串是非法的。
在本次程序实习中，我设计并实现了一个括号匹配的检验程序。
首先，我对括号匹配的问题进行了深入的研究和分析。
我发现，括号匹配问题可以通过使用栈来解决。
栈是一种遵循后进先出原则的数据结构，在括号匹配问题中非常适用。
我使用了一个栈来存储左括号，并在遍历字符串时进行匹配操作。
接下来，我实现了一个简单而高效的括号匹配检验程序。
该程序可以接收一个字符串作为输入，并判断该字符串中的括号是否匹配。
我使用了编程语言（例如C++或Python）来实现该程序，具体的实现细节如下：1. 首先，我创建了一个空栈，用来存储左括号。
2. 然后，我遍历输入的字符串，逐个检查每个字符。
3. 如果当前字符是左括号（例如'('、'{'或'['），则将其推入栈中。
4. 如果当前字符是右括号（例如')'、'}'或']'），则检查栈是否为空。
如果栈为空，则字符串中的右括号没有相应的左括号，该字符串是非法的；如果栈不为空，则将栈顶的左括号弹出并与当前的右括号进行匹配。
如果两个括号不匹配，那么该字符串是非法的。
5. 最后，当遍历完整个字符串后，检查栈是否为空。
如果栈为空，则说明所有的左括号都有相应的右括号，该字符串是合法的；如果栈不为空，则说明字符串中存在未匹配的左括号，该字符串是非法的。
通过实现这个括号匹配的检验程序，我学到了许多关于栈的知识和算法设计的技巧。
此外，我也加深了对括号匹配问题的理解和掌握。
通过编写和调试这个程序，我提高了自己的编程能力和解决问题的能力。
总的来说，本次括号匹配的检验程序实习让我深入了解了括号匹配问题，并通过实际动手编写代码来解决这个问题。
堆栈操作的实验报告
一、实验目的1. 理解堆栈的基本概念和特点。
2. 掌握堆栈的基本操作，包括初始化、进栈、出栈、查看栈顶元素等。
3. 熟悉堆栈在实际问题中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 堆栈的定义与实现2. 堆栈的基本操作3. 堆栈的实际应用四、实验步骤1. 堆栈的定义与实现（1）设计堆栈类（Stack）```cpp#include <iostream>#include <vector>using namespace std;template <typename T>class Stack {private:vector<T> elements; // 使用动态数组存储元素int top; // 栈顶指针public:Stack() : top(-1) {} // 构造函数，初始化栈顶指针为-1 bool isEmpty() const { // 判断栈是否为空return top == -1;}bool isFull() const { // 判断栈是否已满return top == INT_MAX;}void push(const T& element) { // 进栈操作if (isFull()) {cout << "Stack is full." << endl;return;}elements[++top] = element;}bool pop(T& element) { // 出栈操作if (isEmpty()) {cout << "Stack is empty." << endl;return false;}element = elements[top--];return true;}T getTop() const { // 查看栈顶元素if (isEmpty()) {cout << "Stack is empty." << endl;return T();}return elements[top];}};```（2）测试堆栈类```cppint main() {Stack<int> stack;stack.push(1);stack.push(2);stack.push(3);cout << "Stack top element: " << stack.getTop() << endl; // 输出栈顶元素int element;while (stack.pop(element)) {cout << "Pop element: " << element << endl; // 输出出栈元素}return 0;}```2. 堆栈的基本操作（1）初始化：使用构造函数初始化堆栈类，设置栈顶指针为-1。
堆栈及队列的应用实验原理
堆栈及队列的应用实验原理1. 实验介绍本实验将介绍堆栈和队列的基本概念及其应用原理。
首先，我们将学习堆栈和队列的定义和特点，并分析它们在编程中的常见应用场景。
然后，我们将通过实验来深入了解堆栈和队列的运作原理以及如何使用它们解决实际问题。
2. 堆栈的应用原理堆栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，类似于现实生活中的一叠盘子。
堆栈的应用原理基于以下几个操作：•压栈（Push）：将元素添加到堆栈的顶部。
•弹栈（Pop）：将栈顶的元素移除，并返回被移除的元素。
•查看栈顶（Peek）：只查看栈顶的元素，不对堆栈做任何修改。
堆栈的应用可以解决许多问题，例如：1.函数调用和递归：当一个函数调用另一个函数时，调用的函数会先被推入堆栈，直到被调函数返回结果后再从堆栈中弹出。
2.语法解析：语法解析器通常使用堆栈来验证和处理表达式、括号匹配等问题。
3.浏览器历史记录：浏览器的“后退”和“前进”功能可以使用堆栈来实现。
3. 队列的应用原理队列（Queue）是一种先进先出（First In First Out, FIFO）的数据结构，类似于现实生活中的排队。
队列的应用原理基于以下几个操作：•入队（Enqueue）：将元素添加到队列的尾部。
•出队（Dequeue）：将队列的头部元素移除，并返回被移除的元素。
•查看队头（Front）：只查看队列的头部元素，不对队列做任何修改。
队列的应用可以解决许多实际问题，例如：1.任务调度：处理任务的程序通常使用队列来管理待处理的任务列表。
2.消息传递：消息队列是分布式系统中常用的通信方式，用于实现异步处理和解耦系统组件。
3.缓冲区管理：队列用于控制多个生产者和消费者之间的数据传递，以避免资源竞争。
4. 实验步骤本实验将使用编程语言来模拟堆栈和队列的应用原理。
具体步骤如下：1.定义堆栈类和队列类：创建一个堆栈类和一个队列类，分别实现堆栈和队列的基本操作。
C语言实验二、括号匹配
实验二、括号匹配一、问题描述假设一个输入字符串中包含圆括号、方括号和花括号三种类型的括号，以及其它一些任意字符。
编写程序，判别串中的括号是否正确匹配，即必须满足以下条件1.各种左、右括号的个数要一致；2.要符合正确的嵌套规则。
基本方法：在算法中设置一个栈，每读入一个括号，若是右括号，则或者使置于栈顶的最后进入的左括号消解，或者是不合法的情况；若是左括号，则压入栈中，同时在算法的开始和结束时，栈都应该为空，否则不合法。
二、基本要求输入一个算术表达式，利用栈存储结构来存入左括号，然后判断表达式中的括号是否匹配。
三、测试数据（1）([3＋2]+(7*9))（2）[([3/2 ]-[5*6])]（3）[7+8-(8-9])（4）(2+](3*9)))四、实现提示1、算法思路(1)对于栈的操作包括初始化initstack、判断栈是否满sfull、判断栈是否空sempty、入栈push和出栈pop操作。
该函数被主函数调用。
(2)在主函数中输入一个算术表达式，依次取出该算术表达式的某个字符，如果是左括号则入栈，如果是右括号则出栈，并判断右括号与出栈的元素是否匹配。
当算术表达式取完后，再判断栈是否为空，如果不空，则说明括号不匹配。
2、数据结构typedef struct stk//定义的栈结构{char *s; //栈中存放元素int top;//栈顶指针}stack;3、基本操作void initstack(stack *st) /* 栈s1和s2的初始化操作，st为指向s1或s2的指针 */int sfull(stack st) /* 判断栈s1和s2是否满的操作 */int sempty(stack st) /* 判断栈s1和s2是否空的操作 */int push(stack st,char e) /* 入栈操作，e为栈中结点类型 */int pop(stack *st,char *e) /*出栈操作,e为指向栈中结点的指针类型 */5、主程序main(){int i=0;char e;stack s1;//存放左括号的栈char str[100];//存放算术表达式的值initstack(&s1);printf("请输入表达式\n");gets(str);//输入算术表达式while(i<strlen(str)){if (str[i]=='('||str[i]=='['||str[i]=='{'){……}else if (str[i]==')'||str[i]==']'||str[i]=='}'){……else i++;}……}5、输出结果测试数据（1）([3＋2]+(7*9))括号匹配（2）[([3/2 ]-[5*6])]括号匹配（3）[7+8-(8-9])第10个元素左右括号不匹配（4）(2+](3*9)))第4个元素左右括号不匹配。
括号匹配实验报告
括号匹配实验报告实验报告课程名称：数据结构班级：实验成绩：实验名称：栈、队列、字符串和数组学号：批阅教师签字：实验编号：实验⼆姓名：实验⽇期：指导教师：组号：实验时间：⼀、实验⽬的（1）掌握栈、队列、串和数组的抽象数据类型的特征。
（2）掌握栈、队列、串和数组的抽象数据类型在计算机中的实现⽅法。
（3）学会使⽤栈、队列来解决⼀些实际的应⽤问题。
⼆、实验内容与实验步骤（1）实验内容：假设表达式中除了变量名、常量和运算符外，还可以允许两种括号：圆括号和中括号，其嵌套的次序随意，编写程序检验输⼊的表达式中括号的的顺序是否合法。
（2）描述抽象数据类型或设计的函数描述，说明为什么要使⽤这种抽象数据类型，并说明解决设想。
抽象数据类型或函数描述：⾸先定义了⼀个结构体并且声明为栈类型，在其中定义了空间基地址的指针、栈顶指针以及栈存储空间的⼤⼩。
之后设计了Creat _Stack的函数，⽤此函数来创建⼀个空栈，这样可以使⽤堆栈来实现括号匹配的功能，⼜设计了⼀个名为Stack_Full的函数了来判断栈是否已满，若栈未满才可继续之后的压栈功能，如果堆栈已满，则需要使⽤realloc来动态分配空间，扩⼤栈的存储空间。
我还设计了⼀个名为empty的函数，⽤它来判断堆栈是否为空，堆栈为空或不为空时分别返回0或1。
之后设计了名为push和pop的函数来实现括号的⼊栈和出栈，之后设计了名为Match的函数，来判断括号是否匹配，设计了名为clean的函数来清空堆栈，这样可以连续判断不同的多项式的括号是否匹配。
解决设想：对于本题，⾸先我使⽤了栈结构，利⽤栈中数据“先进后出”的特点来实现对括号是否匹配的检验。
实现过程基本如下：从左到右依次扫描多项式，如果遇到左括号便将左括号⼊栈，在所有左括号⼊栈之后便可以扫描到右括号，如果扫描到的右括号和栈顶的左括号可以匹配时，将左括号出栈，以此类推，最后判断栈是否为空，若为空，则括号匹配，否则括号不匹配。
js括号匹配的检验算法
在JavaScript中，可以使用栈数据结构来实现括号匹配的检验算法。
以下是一种基本的算法：1. 创建一个空栈来存储左括号。
2. 遍历输入的字符串，逐个检查字符：-如果是左括号（'('，'{'，'['），将其压入栈中。
-如果是右括号（')'，'}'，']'），检查栈顶元素是否与当前括号匹配：-如果栈为空或栈顶元素不匹配当前括号，则括号不匹配，返回false。
-如果栈顶元素匹配当前括号，则从栈中弹出栈顶元素，继续遍历下一个字符。
3. 遍历结束后，如果栈为空，则所有括号都匹配，返回true；否则，括号不匹配，返回false。
下面是使用JavaScript代码实现该算法的示例：```javascriptfunction isParenthesesMatching(str) {const stack = [];for (let i = 0; i < str.length; i++) {const char = str[i];if (char === '(' || char === '{' || char === '[') {stack.push(char);} else if (char === ')' || char === '}' || char === ']') {if (stack.length === 0) {return false;}const top = stack.pop();if ((char === ')' && top !== '(') ||(char === '}' && top !== '{') ||(char === ']' && top !== '[')) {return false;}}}return stack.length === 0;}// 示例使用：const str1 = '({})'; // 括号匹配，返回trueconst str2 = '{[()]}' // 括号匹配，返回trueconst str3 = '({})['; // 括号不匹配，返回falseconsole.log(isParenthesesMatching(str1)); // trueconsole.log(isParenthesesMatching(str2)); // trueconsole.log(isParenthesesMatching(str3)); // false```使用这个算法，你可以检验一个字符串中的括号是否匹配。
括号匹配检测实验报告(3篇)
第1篇实验名称：括号匹配检测实验目的：1. 理解括号匹配的基本原理。
2. 掌握使用栈进行括号匹配检测的方法。
3. 通过编程实现括号匹配检测功能。
实验时间：2023年X月X日实验地点：实验室实验器材：1. 计算机2. 编程软件（如Python、Java等）3. 文档编辑器实验内容：一、实验原理括号匹配检测是计算机科学中的一个基础问题，它涉及到字符串中括号的正确配对。
常见的括号包括圆括号()、方括号[]和花括号{}。
一个有效的括号序列是指，序列中的每个左括号都有一个对应的右括号，并且括号内的内容可以嵌套。
括号匹配检测通常使用栈（Stack）这一数据结构来实现。
栈是一种后进先出（Last In First Out，LIFO）的数据结构，适用于括号匹配检测的原因是括号的匹配顺序与它们出现的顺序相反。
二、实验步骤1. 设计算法：确定使用栈进行括号匹配检测的算法步骤。
2. 编写代码：根据算法步骤，编写实现括号匹配检测功能的代码。
3. 测试代码：使用不同的测试用例对代码进行测试，确保其正确性。
4. 分析结果：对测试结果进行分析，评估代码的性能和正确性。
三、实验代码以下是一个使用Python实现的括号匹配检测的示例代码：```pythondef is_balanced(s):stack = []bracket_map = {')': '(', ']': '[', '}': '{'}for char in s:if char in bracket_map.values():stack.append(char)elif char in bracket_map.keys():if not stack or bracket_map[char] != stack.pop(): return Falsereturn not stack测试用例test_cases = ["((()))", True"([{}])", True"({[}])", False"((())", False"()[]{}", True"([)]", False"(({[]}))", True"" True]for case in test_cases:print(f"Input: {case}, Output: {is_balanced(case)}")```四、实验结果与分析通过上述代码，我们对一系列测试用例进行了括号匹配检测。
括号匹配问题
东华理工大学长江学院课程设计报告数据结构课题设计报告设计题目：括号匹配问题姓名：班级：学号：指导老师：二0一0年五月目录1．设计内容 (1)问题描述 (1)问题分析 (1)2．概要设计 (2)2-1模块一：初始化一个堆栈 (2)2-2模块二：进栈 (2)2-3模块三：测试堆栈是否为空 (2)2-4模块四：退栈 (2)2-5模块五：各模块间的调用关系 (2)3．算法描述 (3)3-1程序流程图： (3)3-2程序代码： (4)4．算法分析 (6)5．心得体会 (8)6．参考资料 (8)1．设计内容问题描述假设一个算术表达式中可包含三种括号：圆括号，方括号和花括号且这三种括号可按任意次序嵌套使用。
试利用栈的运算，编写判别给定表达式中所含括号是否正确配对出现的算法。
问题分析此程序须要完成如下要求：表达式中有三种括号：圆括号、方括号和花括号，嵌套顺序任意。
实现本程序需要解决：①用什么数据结构；②怎样实现判断括号是否匹配；③括号匹配与否有几种情况；④输出与输入数据的形式。
本程序的难点在于怎么判断括号是否匹配。
2．概要设计2-1模块一：初始化一个堆栈堆栈的顺序存储结构可以利用一个具有M个元素的数组STACK[0..M-1]来描述。
其中，STACK作为堆栈的名字，且不妨设：#define M 100 */定义堆栈的最大容量，并初始化栈顶指针变量top=-1。
2-2模块二：进栈在容量为M的堆栈中插入一个新的元素E[i],栈顶元素的位置由top指出。
新的数据元素进栈，将栈顶指针加1，然后将新的数据元素E[i]插入到修改以后的top指出的新的栈顶位置上。
2-3模块三：测试堆栈是否为空测试堆栈是的栈顶指针top是否为-1。
2-4模块四：退栈从堆栈中退出当前栈顶元素，并保存在变量item中，同时将栈顶指针减1修改栈顶指针位置。
2-5模块五：各模块间的调用关系首先创建一个堆栈并初始化，依次读入字符直到文件的末尾。
如果读得的字符为左括号，则将其压入堆栈。
括号匹配检验
括号匹配检验利用栈编写满足下列要求的括号匹配检验程序：假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，即([]())或[([][])]等为正确的格式，[(]或([())或(()])均为不正确的格式。
输入一个包含上述括号的表达式，检验括号是否配对。
Input第一行：输入一个包含圆括号或方括号、不超过80个字符的表达式串。
Output第一行：若输入表达式括号匹配，输出"matching"; 若不匹配，输出具体信息:"isn't matched pairs", 或"lack of left parenthesis"或"lack of right parenthesis"typedef char SElemType;#include"malloc.h"#include"stdio.h"#include"math.h"#include"process.h" // exit()#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等#define STACK_INIT_SIZE 10 // 存储空间初始分配量#define STACKINCREMENT 2 // 存储空间分配增量struct SqStack{SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间，以元素为单位}; // 顺序栈Status InitStack(SqStack &S){ S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));S.top=S.base;if(!S.base) return ERROR;S.stacksize=STACK_INIT_SIZE;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top) return TRUE;else return FALSE;}Status Push(SqStack &S,SElemType e){ if(S.top-S.base>=S.stacksize) {S.base=(SElemType*)realloc(S.base,(STACK_INIT_SIZE+S.stacksize)*sizeof(SElemType)); if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize=S.stacksize+STACK_INIT_SIZE;}*S.top=e;S.top++;return OK;}Status Pop(SqStack &S,SElemType &e){ if(S.base==S.top) return ERROR;e=*--S.top;return OK;}void check(){ // 对于输入的任意一个字符串，检验括号是否配对SqStack s;SElemType ch[80],*p,e;if(InitStack(s)) // 初始化栈成功{//printf("请输入表达式\n");scanf("%s",ch);p=ch;while(*p) // 没到串尾switch(*p){case '(':case '[':Push(s,*p);p++;break; // 左括号入栈，且p++case ')':case ']':if(!StackEmpty(s)) // 栈不空{Pop(s,e); // 弹出栈顶元素if(*p==')'&&e!='('||*p==']'&&e!='[')// 弹出的栈顶元素与*p不配对{printf("isn't matched pairs\n");exit(ERROR);}else{p++;break; // 跳出switch语句}}else // 栈空{printf("lack of left parenthesis\n");exit(ERROR);}default: p++; // 其它字符不处理，指针向后移}if(StackEmpty(s)) // 字符串结束时栈空printf("matching\n");elseprintf("lack of right parenthesis\n");}}void main() {check(); }。
表达式括号匹配配对判断 大二数据结构实验
实验表达式括号匹配配对判断问题1，问题的描述假设一个算法表达式中包括圆括号，方括号两种，设计判别表达式中括号是否正确匹配的算法。
2，数据结构设计（1）匹配判别发生在右括号出现时，且被匹配的左括号应是距离右括号最近被输入的，二不是最先被输入的括号，即“先入后匹配”。
因此用栈来解决。
struct Node{int top;char data[stacksize];};Node node;void InitStack( ) // 初始化栈{node.top=-1;}（2）一是表达式的串；二是栈。
串可以采用顺序表表示。
所以采用顺序栈，站元素类型为字符型。
sqstack(int n){ base=newT[m];if(base=NULL){cout<<“创栈失败”；exit（1）；}stacksize=m;top=-1;}}3,算法设计（1）进栈的算法设计voidPush(charx){if(node.top==stacksize-1);node.top++;node.data[node.top]=x;}（2）出栈的算法设计void Pop(char &x){if(node.top==-1);x=node.data[node.top--];}（3）判断是否匹配的算发。
如果右括号，进栈，取下个字符；如果是左括号，出栈，取下个字符；最后判断栈是否为空；得出结论。
3．1因为其中包含几种括号，所以用采用switch语句for(i=0;*(p+i)!='\0'&&count!=0;i++){switch (*(p+i)){case '(' :Push(*(p+i)) ;break ;case '[' :Push(*(p+i) ) ;break ;case ')' :{Pop(e) ;if ( e!='(' )count=0 ;};break ;case ']' :{Pop(e) ;if ( e!='[' )count=0 ;}; break ;default:break;}}3．2利用进出栈判断括号是否匹配if ( !StackEmpty () || count==0 ) //条件为:栈不空，而且有出现括号不匹配的情况{cout<<"括号无法匹配！"<<endl;cout<<"你想要继续吗？(y/n)"<<endl;cin>>s;if(s=='y'||s=='Y')goto input;else if(s=='n'||s=='N')cout<<"退出程序!"<<endl;return 0;}else{cout<<"括号能够匹配!"<<endl;cout<<"你想要继续吗？(y/n)"<<endl;cin>>s;if(s=='y'||s=='Y')goto input;else if(s=='n'||s=='N')cout<<"退出程序!"<<endl;return 0;}4．测试与运行（1）显示菜单，如下图：（2）运行结果如下图：5．调试的收获通过这次实验好的感觉到自己还有不足之处，一个程序高那么久才搞定，以后要多加练习。
栈和队列的应用实例
栈和队列的应用实例一、栈的应用实例1.计算器程序计算器程序是栈的一个经典应用，它可以通过将表达式转换成后缀表达式，再利用栈进行运算得出结果。
具体实现过程如下：（1）将中缀表达式转换为后缀表达式。
（2）利用栈进行后缀表达式的运算。
2.浏览器前进后退功能浏览器前进后退功能也是栈的一个应用。
当用户点击浏览器的前进或后退按钮时，浏览器会将当前页面的URL压入一个栈中。
当用户点击前进或后退按钮时，浏览器会从栈中弹出上一个或下一个URL并加载。
3.括号匹配问题括号匹配问题也是栈的一个常见应用。
当我们需要判断一段代码中括号是否匹配时，可以使用栈来实现。
遍历代码中每个字符，如果是左括号，则将其压入栈中；如果是右括号，则从栈顶弹出一个左括号进行匹配。
如果最终栈为空，则说明所有括号都匹配成功。
二、队列的应用实例1.打印队列打印队列是队列的一个典型应用。
在打印机资源有限且多人共享的情况下，打印队列可以帮助我们管理打印任务的顺序。
每当有一个新的打印任务到达时，就将其加入队列中。
当打印机空闲时，从队列中取出第一个任务进行打印，直到队列为空。
2.消息队列消息队列也是队列的一个重要应用。
在分布式系统中，不同节点之间需要传递消息进行通信。
为了保证消息传递的可靠性和顺序性，可以使用消息队列来实现。
每当一个节点发送一条消息时，就将其加入到消息队列中。
接收方从消息队列中取出最早的一条消息进行处理。
3.广度优先搜索广度优先搜索也是队列的一个常见应用。
在图论和网络分析中，广度优先搜索可以帮助我们寻找最短路径和连通性等问题。
具体实现过程如下：（1）将起点加入到队列中。
（2）从队首取出一个节点，并将与其相邻且未访问过的节点加入到队尾。
（3）重复步骤（2），直到找到终点或者遍历完所有节点。
以上是栈和队列的一些应用实例，在实际编程过程中需要根据具体情况选择合适的数据结构来解决问题。
堆栈应用实验报告
堆栈应用实验报告一、实验目的本实验主要是通过堆栈的实际应用来进一步深入了解堆栈的概念、原理和使用方法，并学会基于堆栈的算法设计和编程。
二、实验器材1.计算机本身及编程环境。
2.编程软件：Visual Studio 2010（或以上版本）。
三、实验内容及要求1.堆栈的定义与基本操作。
2.堆栈的应用。
（1）逆波兰表达式求值。
（2）括号匹配。
四、实验原理堆栈是一种先进后出的数据结构，常见的基本操作包括以下几个：入栈（Push），将元素添加到堆栈的上方。
出栈（Pop），弹出并返回堆栈的顶部元素。
判空（Empty），判断堆栈是否为空。
堆栈的数据结构通常有两种实现方法：数组实现链表实现逆波兰表达式（Reverse Polish Notation）是一种后缀表达式，其中操作符写在操作数的后面，例如，“1 2 +”等价于中缀表达式“1 + 2”。
使用堆栈可以方便的求解逆波兰表达式，步骤如下：遍历逆波兰表达式，遇到操作数则入栈。
遇到操作符时，弹出栈顶两个元素，进行运算，并将结果入栈。
将最终结果从栈中弹出。
括号匹配问题是指给定一个字符串，判断其中的括号是否成对出现，且出现顺序正确，例如“()”，“(（））”等都属于匹配的情况，但“（[）]”不匹配。
遍历字符串，遇到左括号则入栈。
遇到右括号时，弹出栈顶元素进行匹配，如果匹配成功则继续遍历，否则直接返回不匹配。
遍历完成后，若堆栈为空，则返回匹配，否则返回不匹配。
五、实验过程```c++#include<iostream>using namespace std;const int MAXN = 10001;int stk[MAXN], top;struct node {char data;node* next;};node* stk;void pop() {if (empty()) return;node* p = stk;stk = stk->next;delete p;}bool empty() {return top == 0;}bool match(char a, char b) {if (a == '(' && b == ')') return true;if (a == '[' && b == ']') return true;if (a == '{' && b == '}') return true;return false;}六、实验结果输入："5 1 2 + 4 * + 3 -"输出："14"七、实验心得对于入门学习堆栈的同学来说，可以先尝试使用基本数据结构（数组或链表）实现堆栈，并完成一些简单的堆栈操作。
数据结构-堆栈和队列实验报告
数据结构-堆栈和队列实验报告数据结构堆栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的堆栈和队列的基本概念、操作原理以及实际应用。
通过实际编程实现堆栈和队列的相关操作，加深对其特性的认识，提高编程能力和解决问题的能力。
二、实验环境本次实验使用的编程语言为 Python，开发工具为 PyCharm。
三、实验原理（一）堆栈（Stack）堆栈是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
可以将堆栈想象成一个只能从一端进行操作的容器，新元素总是被添加到这一端（称为栈顶），而取出元素也只能从栈顶进行。
堆栈的基本操作包括：1、｀push`：将元素压入堆栈。
2、｀pop`：弹出堆栈顶部的元素。
3、｀peek`：查看堆栈顶部的元素，但不弹出。
（二）队列（Queue）队列是另一种特殊的线性表，其操作遵循“先进先出”（First In First Out，FIFO）的原则。
可以将队列想象成一个排队的队伍，新元素在队尾加入，而取出元素从队首进行。
队列的基本操作包括：1、｀enqueue`：将元素加入队列的尾部。
2、｀dequeue`：取出并删除队列头部的元素。
3、｀front`：查看队列头部的元素，但不取出。
四、实验内容（一）堆栈的实现｀｀｀pythonclass Stack:def ＿_init__(self)：selfitems ＝def push(self, item)：selfitemsappend(item)def pop(self)：if not selfis_empty(）：return selfitemspop(）else:return ＂Stack is empty" def peek(self)：if not selfis_empty(）：return selfitems-1else:return ＂Stack is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（二）队列的实现｀｀｀pythonclass Queue:def ＿_init__(self)：selfitems ＝def enqueue(self, item)：selfitemsappend(item)def dequeue(self)：if not selfis_empty(）：return selfitemspop(0) else:return ＂Queue is empty" def front(self)：if not selfis_empty(）：return selfitems0else:return ＂Queue is empty" def is_empty(self)：return len(selfitems) ＝＝ 0 def size(self)：return len(selfitems)｀｀｀（三）应用实例1、利用堆栈实现括号匹配的验证｀｀｀pythondef is_balanced_parentheses(exp)：stack ＝ Stack(）for char in exp:if char in ＇（｛＇：stackpush(char)elif char in ＇）｝＇：if stackis_empty(）：return Falsetop ＝ stackpop(）if （char ＝＝＇）＇ and top!＝＇（＇） or （char ＝＝＇｝＇ and top!＝＇｛＇） or （char ＝＝＇＇ and top!＝＇＇）：return Falsereturn stackis_empty(）｀｀｀2、利用队列实现打印杨辉三角的前 n 行｀｀｀pythondef print_yanghui_triangle(n)：queue ＝ Queue(）queueenqueue(1)print(1)for i in range(1, n)：prev_row ＝for ＿ in range(i ＋ 1)：num ＝ queuedequeue(）prev_rowappend(num)print(num, end=＂＂）if ＿＜ i:new_num ＝ prev_row_ ＋（prev_row_ 1 if ＿＞ 0 else 0) queueenqueue(new_num)print(）｀｀｀五、实验结果与分析（一）堆栈实验结果对于括号匹配的验证，输入`＂（（（）））＂｀，输出为`True`，表示括号匹配正确；输入`＂（（（））＂｀，输出为`False`，表示括号匹配错误。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
深圳大学实验报告课程名称：数据结构实验与课程设计实验项目名称：堆栈应用括号匹配实验学院：计算机与软件学院专业：未分指导教师：杨芳报告人：姜家祥学号：2013150387 班级：08实验时间：2013-10-9实验报告提交时间：2014-10-10教务处制一、实验目的掌握堆栈的基本原理掌握堆栈的存储结构掌握堆栈的进栈、弹栈、判断栈空的实现方法掌握应用堆栈实现括号匹配的原理和实现方法二、实验要求熟悉C++语言编程熟练使用C++语言实现堆栈的进栈Push、插入Pop、判断栈空等操作熟练使用堆栈实现括号匹配算法三、实验内容本次实验有两项内容：（一）堆栈应用括号匹配1、问题描述一个算术表达式中包括圆括号、方括号和花括号三种形式的括号编程实现判别表达式中括号是否正确匹配的算法2、算法顺序扫描算术表达式若算术表达式扫描完成，此时如果栈空，则正确返回(0)；如果栈未空，说明左括号多于右括号，返回(-3)从算术表达式中取出一个字符，如果是左括号(‘(‘或‘[‘或‘{‘)，则让该括号进栈(PUSH)如果是右括号(‘)‘或‘]‘或‘}‘)：⑵ 、如果栈为空，则说明右括号多于左括号，返回(-2)⑵、如果栈不为空，则从栈顶弹出(POP)一个括号：若括号匹配，则转1继续进行判断；否则，说明左右括号配对次序不正确，返回(-1)3、输入第一行：样本个数，假设为n。
第二到n+1行，每一行是一个样本（算术表达式串），共n个测试样本。
4、输入样本4{[(1+2)*3]-1}{[(1+2]*3)-1}(1+2)*3)-1}{[(1+2)*3-1]5、输出共有n行，每一行是一个测试结果，有四种结果：0：左右括号匹配正确{[(1+2)*3]-1}-1：左右括号配对次序不正确{[(1+2]*3)-1}-2：右括号多于左括号(1+2)*3)-1}-3：左括号多于右括号{[(1+2)*3-1]6、输出样本-1-2-3（二）数制转换1、问题描述对于任意十进制数转换为k进制，包括整数部分和小数部分转换。
整数部分采用除k求余法，小数部分采用乘k取整法例如x=19.125，求2进制转换整数部分19，小数部分0.12519 / 2 = 9 ... 10.125 * 2 = 0.25 09 / 2 = 4 ... 10.25 * 2 = 0.5 04 / 2 = 2 ... 0 0.5 * 2 = 1 (1)2 / 2 = 1 01 / 2 = 0 (1)所以整数部分转为 10011，小数部分转为0.001，合起来为10011.001提示整数部分可用堆栈，小数部分可用队列实现注意：必须按照上述方法来实现数制转换，其他方法0分2、输入第一行输入一个t，表示下面将有t组测试数据。
接下来每行包含两个参数n和k，n表示要转换的数值，可能是非整数；k表示要转换的数制，1<k<=163、输出对于每一组测试数据，每行输出转换后的结果，结果精度到小数点后3位4、输入样本219.125 215.125 165、输出样本10011.001F.200四、程序清单#include<iostream>using namespace std;#include<string>#define Max_Size 100typedef struct Stack{ //定义栈char base[Max_Size];int top;}Stack;void InitStack(Stack &S){ //构造空栈S.top=0;}int Push(Stack &S,char ch){ //元素进栈S.top++;S.base[S.top]=ch;return 1;}int Pop(Stack &S,char ch){ //元素出栈S.top--;ch=S.base[S.top];return 1;}int Empty(Stack &s,int n){if(s.top==0){return 1;}else{return 0;}}int Pipei(Stack &S,string S1){ //匹配int i,m=0,n=0,num=0,num1=0; char c,ch,ch1,ch2[100];InitStack(S);for(i=0;i<S1.length();i++){c=S1[i];if(c=='('||c==')'||c=='{'||c=='}'||c=='['||c==']')ch2[m++]=c;}//把字符组S1的括号复制到ch2中for(i=0;i<=m-1;i++){ch=ch2[i];if(ch=='('||ch=='{'||ch=='[')Push(S,ch);//左括号，进栈if(ch==')'||ch=='}'||ch==']'){num1++;if((ch==')'&&S.base[S.top]=='(')||(ch=='}'&&S.base[S.top]=='{')||(ch==']'&&S.base[S.top]== '['))Pop(S,ch1);//右括号匹配栈顶左括号，左括号出栈else{i=m-1;return -1;}//左右括号不匹配if(Empty(S,n)&&i<m-1)return -2;//右括号多于左括号}}if(!Empty(S,n))//左括号多于右括号return -3;if(Empty(S,n))//左右括号匹配return 0;}int main(){Stack S;string P;int t,x;//freopen("cin.txt","r",stdin);cin>>t;while(t--){cin>>P;x=Pipei(S,P);cout<<x<<endl;}return 0;}******************************************************************************* #include<iostream>using namespace std;#define Max_Value 100typedef struct Num{int base[Max_V alue];int top;}Num;void InitNum(Num &S){S.top=0;}int Push(Num &S,int a ){if(S.top>=Max_Value)return -1;S.top++;S.base[S.top]=a;return 1;}int Pop(Num &S,int &a){if(S.top<=0)return -1;a=S.base[S.top];S.top--;return 1;}int Empty(Num &S){if(S.top==0)return 1;elsereturn 0;}void Num_1(Num &S,int a,int k){InitNum(S);int e;while(a){Push(S,a%k);a=a/k;}while(!Empty(S)){Pop(S,e);if(e>=10)cout<<char(e%10+65);elsecout<<e;}}void Num_2(Num &S,double a,int k){InitNum(S);int b,i,e,j=0;for(i=0;i<3;i++){Push(S,a*k);b=a*k;a=a*k-b;}for(j=1;j<=3;j++){if(S.base[j]>=10)cout<<char(S.base[j]%10+65);elsecout<<S.base[j];}}int main(){int t,k,m;double a,n;Num S;//freopen("cin1.txt","r",stdin);cin>>t;while(t--){cin>>a>>k;m=a;n=a-m;Num_1(S,m,k);cout<<".";Num_2(S,n,k);cout<<endl;}return 0;}五、程序运行时截图六、实验心得与体会（实验中遇到的问题及解决方案，或写点感想）对于第一题，感觉还好，就是有时候感觉有点混，第二题较麻烦，问题大大小小不断，慢慢调试，查看，百度2、教师批改学生实验报告时间应在学生提交实验报告时间后10日内。
－11－。