数据结构实验报告(栈_括号匹配) (1)

合集下载

栈的实验报告结论(3篇)

栈的实验报告结论(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)测试程序:验证了栈在程序设计中的应用。

括号匹配栈实验报告

括号匹配栈实验报告

一、实验目的本次实验旨在通过编写程序实现括号匹配功能,加深对栈数据结构原理的理解和应用。

通过实验,掌握栈的基本操作,如入栈、出栈、判断栈空等,并学会利用栈解决括号匹配问题。

二、实验原理1. 栈是一种后进先出(LIFO)的线性数据结构,它只允许在栈顶进行插入和删除操作。

2. 括号匹配问题是指在一个字符串中,判断左右括号是否成对出现,且对应匹配。

3. 在解决括号匹配问题时,可以使用栈来存储遇到的左括号,并在遇到右括号时进行匹配。

如果栈为空或括号不匹配,则判断为无效括号。

如果栈为空,表示括号匹配正确,否则表示不匹配。

三、实验内容1. 定义栈结构体,包括栈的最大容量、栈顶指针、栈底指针、栈元素数组等。

2. 编写栈的基本操作函数,如初始化、入栈、出栈、判断栈空等。

3. 编写括号匹配函数,利用栈实现括号匹配功能。

4. 编写主函数,接收用户输入的字符串,调用括号匹配函数进行判断,并输出结果。

四、实验步骤1. 定义栈结构体和栈的基本操作函数。

```c#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int top;} Stack;void InitStack(Stack s) {s->top = -1;}int IsEmpty(Stack s) {return s->top == -1;}void Push(Stack s, char x) {if (s->top == MAX_SIZE - 1) { return;}s->data[++s->top] = x;}char Pop(Stack s) {if (s->top == -1) {return '\0';}return s->data[s->top--];}```2. 编写括号匹配函数。

```cint BracketMatch(char str) {Stack s;InitStack(&s);while (str) {if (str == '(' || str == '[' || str == '{') {Push(&s, str);} else if (str == ')' || str == ']' || str == '}') {if (IsEmpty(&s)) {return 0; // 不匹配}char c = Pop(&s);if ((c == '(' && str != ')') || (c == '[' && str != ']') || (c == '{' && str != '}')) {return 0; // 不匹配}}str++;}return IsEmpty(&s); // 栈为空,匹配成功}```3. 编写主函数。

数据结构实验报告栈

数据结构实验报告栈

数据结构实验报告:栈摘要:本实验报告旨在介绍栈这一重要的数据结构,以及在实际应用中的使用。

栈是一种先进后出(LIFO)的数据结构,在计算机科学中有着广泛的应用。

本报告将详细介绍栈的定义、基本操作以及应用实例,并根据实验结果进行分析和总结。

1. 引言栈是一种基于线性表的数据结构,具有后进先出(LIFO)的特性。

它可以通过两个基本操作来实现:push(入栈)将元素添加到栈顶,pop(出栈)将栈顶元素移除。

栈在计算机科学中被广泛应用,如函数调用、表达式求值、括号匹配等。

2. 栈的实现栈可以通过数组或链表来实现。

数组实现的栈称为顺序栈,链表实现的栈称为链式栈。

无论是哪种实现方式,都需要实现以下基本操作:- push(element): 将元素添加到栈顶。

- pop(): 移除栈顶元素并返回。

- top(): 返回栈顶元素的值。

- isEmpty(): 判断栈是否为空。

- isFull(): 判断栈是否已满(仅顺序栈需要实现)。

3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。

每当一个函数被调用时,当前函数的局部变量、返回地址等信息都会被压入栈中。

当函数执行完毕时,这些信息会从栈中弹出,继续执行上一级函数。

3.2 表达式求值栈常用于表达式求值,特别是中缀表达式的转换和计算。

通过将中缀表达式转换为后缀表达式,可以方便地进行计算。

栈可以临时存储运算符,并根据运算符的优先级进行弹出和计算。

3.3 括号匹配栈的一个重要应用是括号匹配。

通过遍历字符串,将左括号压入栈中。

每当遇到右括号时,如果栈顶元素是匹配的左括号,则弹出栈顶元素;否则,表示括号不匹配。

4. 实验结果与分析根据我们对栈的实现和应用进行的实验,以下是我们得到的结论:- 通过数组实现的顺序栈在空间上存在一定的限制,可能会出现栈溢出的情况。

- 通过链表实现的链式栈没有空间限制,可以动态地添加和删除元素。

- 栈在函数调用和表达式求值中展现出了高效的性能,并能够简化程序的设计。

栈的运用实验报告

栈的运用实验报告

一、实验目的1. 理解栈的基本概念、特点及逻辑结构;2. 掌握栈的顺序存储和链式存储结构;3. 熟练掌握栈的基本操作,如入栈、出栈、判断栈空等;4. 理解栈在递归算法中的应用;5. 探究栈在实际问题中的应用。

二、实验内容1. 栈的定义与特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈在递归算法中的应用6. 栈在实际问题中的应用三、实验步骤1. 栈的定义与特点(1)栈是一种后进先出(LIFO)的数据结构;(2)栈的元素只能从一端(栈顶)进行插入和删除操作;(3)栈具有两个基本操作:入栈和出栈。

2. 栈的顺序存储结构(1)使用数组来实现栈的顺序存储结构;(2)定义一个数组作为栈的存储空间;(3)定义栈顶指针top,初始值为-1;(4)定义栈的最大容量maxSize。

3. 栈的链式存储结构(1)使用链表来实现栈的链式存储结构;(2)定义一个链表节点,包含数据域和指针域;(3)定义栈顶指针top,初始时指向链表头节点。

4. 栈的基本操作(1)入栈操作:将元素插入到栈顶,栈顶指针向上移动;(2)出栈操作:删除栈顶元素,栈顶指针向下移动;(3)判断栈空:判断栈顶指针是否为-1,是则栈空,否则栈非空。

5. 栈在递归算法中的应用(1)斐波那契数列的递归算法;(2)汉诺塔问题;(3)迷宫问题。

6. 栈在实际问题中的应用(1)括号匹配问题;(2)表达式求值问题;(3)递归函数的调用栈。

四、实验结果与分析1. 栈的定义与特点通过本次实验,我们深入理解了栈的基本概念、特点及逻辑结构,掌握了栈的后进先出特性。

2. 栈的顺序存储结构使用数组实现栈的顺序存储结构,操作简单高效。

在实验过程中,我们实现了栈的基本操作,如入栈、出栈、判断栈空等。

3. 栈的链式存储结构使用链表实现栈的链式存储结构,具有灵活性和扩展性。

在实验过程中,我们实现了栈的基本操作,如入栈、出栈、判断栈空等。

4. 栈的基本操作通过实验,我们熟练掌握了栈的基本操作,如入栈、出栈、判断栈空等,为后续递归算法和实际问题中的应用奠定了基础。

编写一个括号匹配的检验的程序实习报告

编写一个括号匹配的检验的程序实习报告

编写一个括号匹配的检验的程序实习报告在计算机科学领域,括号匹配是一个常见的问题。

括号匹配指的是在一个字符串中,所有的括号都必须正确地成对出现。

如果所有的括号都能正确地匹配,那么该字符串是合法的;否则,该字符串是非法的。

在本次程序实习中,我设计并实现了一个括号匹配的检验程序。

首先,我对括号匹配的问题进行了深入的研究和分析。

我发现,括号匹配问题可以通过使用栈来解决。

栈是一种遵循后进先出原则的数据结构,在括号匹配问题中非常适用。

我使用了一个栈来存储左括号,并在遍历字符串时进行匹配操作。

接下来,我实现了一个简单而高效的括号匹配检验程序。

该程序可以接收一个字符串作为输入,并判断该字符串中的括号是否匹配。

我使用了编程语言(例如C++或Python)来实现该程序,具体的实现细节如下:1. 首先,我创建了一个空栈,用来存储左括号。

2. 然后,我遍历输入的字符串,逐个检查每个字符。

3. 如果当前字符是左括号(例如'('、'{'或'['),则将其推入栈中。

4. 如果当前字符是右括号(例如')'、'}'或']'),则检查栈是否为空。

如果栈为空,则字符串中的右括号没有相应的左括号,该字符串是非法的;如果栈不为空,则将栈顶的左括号弹出并与当前的右括号进行匹配。

如果两个括号不匹配,那么该字符串是非法的。

5. 最后,当遍历完整个字符串后,检查栈是否为空。

如果栈为空,则说明所有的左括号都有相应的右括号,该字符串是合法的;如果栈不为空,则说明字符串中存在未匹配的左括号,该字符串是非法的。

通过实现这个括号匹配的检验程序,我学到了许多关于栈的知识和算法设计的技巧。

此外,我也加深了对括号匹配问题的理解和掌握。

通过编写和调试这个程序,我提高了自己的编程能力和解决问题的能力。

总的来说,本次括号匹配的检验程序实习让我深入了解了括号匹配问题,并通过实际动手编写代码来解决这个问题。

栈的应用实验报告

栈的应用实验报告

栈的应用实验报告导言:在计算机科学领域中,数据结构是一项非常重要的基础。

栈是一种常用的数据结构,它在算法设计和软件开发中具有广泛的应用。

本实验旨在探索栈的应用,并通过实际操作来加深对栈数据结构的理解。

实验目的:1. 了解栈的定义和基本操作。

2. 掌握栈在实际问题中的应用方法。

3. 培养问题分析和解决的能力。

实验步骤:1. 实现栈的基本操作:压入(push)和弹出(pop)。

2. 针对以下实际问题,设计并实现相应的栈应用。

一、括号匹配问题括号匹配问题是指在一个字符串中,括号的开闭配对是否正确。

例如,"{[()]}"是正确的括号匹配,而"{[(])}"则是错误的括号配对。

通过使用栈,我们可以很方便地解决这个问题。

算法步骤如下:1. 遍历字符串的每个字符。

2. 若字符是左括号,则将其压入栈中。

3. 若字符是右括号,则检查栈是否为空,若为空则配对错误;若非空,则弹出栈顶元素并检查是否与右括号匹配。

4. 遍历结束后,若栈为空,则括号匹配正确,否则匹配错误。

二、函数调用问题在计算机程序中,函数的调用和返回遵循"先进后出"的原则,即后调用的函数先返回。

栈提供了一种便捷的方式来管理函数调用和返回过程。

在实际的编程中,我们可以使用栈来存储函数的局部变量和返回地址等信息。

例如,以下是一个简单的函数调用示例:1. 函数A调用函数B。

2. 函数B在栈中保存局部变量和返回地址。

3. 函数B执行完毕后,从栈中弹出局部变量和返回地址,程序继续执行函数A。

三、逆波兰表达式求值问题逆波兰表达式是一种不使用括号来表示表达式的方法,而是通过运算符放置在操作数之后的方式来表示。

例如,表达式"2 3 +"等价于中缀表达式"2 + 3"。

利用栈,我们可以很方便地对逆波兰表达式进行求值。

算法步骤如下:1. 遍历逆波兰表达式的每个元素。

2. 若元素是操作数,则将其压入栈中。

数据结构栈和队列实验报告

数据结构栈和队列实验报告

数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。

通过编程实现栈和队列的相关操作,加深对其特性的认识,并能够运用栈和队列解决实际问题。

二、实验环境本次实验使用的编程语言为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)的操作。

栈的实验报告心得(3篇)

栈的实验报告心得(3篇)

第1篇一、实验背景栈(Stack)是一种先进后出(First In Last Out,FILO)的数据结构,它是计算机科学中常用的数据存储方式之一。

在栈中,元素的插入和删除操作只能在栈顶进行。

本实验旨在通过编程实现栈的基本操作,加深对栈的理解和应用。

二、实验目的1. 理解栈的基本概念和特点。

2. 掌握栈的基本操作,如入栈、出栈、判断栈空、判断栈满等。

3. 熟悉栈在实际问题中的应用,提高编程能力。

三、实验内容1. 栈的定义与实现2. 栈的基本操作a. 入栈(Push)b. 出栈(Pop)c. 判断栈空(IsEmpty)d. 判断栈满(IsFull)e. 获取栈顶元素(Peek)3. 栈的应用实例四、实验过程1. 栈的定义与实现首先,我们需要定义一个栈的数据结构。

在C语言中,可以使用结构体(struct)来实现栈:```cdefine MAX_SIZE 100 // 定义栈的最大容量typedef struct {int data[MAX_SIZE]; // 存储栈元素的数组int top; // 栈顶指针} Stack;```2. 栈的基本操作(1)入栈(Push)入栈操作将一个元素添加到栈顶。

在执行入栈操作之前,需要判断栈是否已满。

如果栈未满,则将元素添加到栈顶;如果栈已满,则返回错误信息。

```cint Push(Stack s, int value) {if (s->top == MAX_SIZE - 1) {return -1; // 栈满}s->data[++s->top] = value; // 将元素添加到栈顶return 0; // 成功入栈}```(2)出栈(Pop)出栈操作将栈顶元素移除。

在执行出栈操作之前,需要判断栈是否为空。

如果栈不为空,则将栈顶元素移除;如果栈为空,则返回错误信息。

```cint Pop(Stack s, int value) {if (s->top == -1) {return -1; // 栈空}value = s->data[s->top--]; // 移除栈顶元素return 0; // 成功出栈}```(3)判断栈空(IsEmpty)判断栈空操作用于判断栈是否为空。

括号匹配检测实验报告

括号匹配检测实验报告

括号匹配检测实验报告本实验旨在设计和实现一个括号匹配检测算法,检测给定字符串中的括号是否正确匹配。

实验原理:括号匹配检测是一种常见的算法问题。

其基本原理是利用栈(Stack)数据结构进行括号的匹配。

当遇到左括号时,将其入栈;当遇到右括号时,判断栈顶元素是否与其对应的左括号相匹配,若匹配则将栈顶元素出栈,继续检测下一个字符;若不匹配,则说明括号不正确匹配,返回匹配失败;最后,若栈为空,则说明所有括号都正确匹配,返回匹配成功。

实验步骤:1. 设计栈数据结构及括号匹配检测算法。

2. 实现算法代码。

3. 设计测试用例,包括正确匹配和不正确匹配的字符串。

4. 运行测试用例,检测算法的正确性和效率。

5. 分析实验结果并撰写实验报告。

实验代码:以下是一个用Python语言实现的括号匹配检测算法示例代码:pythonclass Stack:def __init__(self):self.stack = []def is_empty(self):return len(self.stack) == 0def push(self, element):self.stack.append(element)def pop(self):if not self.is_empty():return self.stack.pop()else:return Nonedef peek(self):if not self.is_empty():return self.stack[-1]else:return Nonedef bracket_match(string):stack = Stack() # 创建栈对象brackets = {'(': ')', '[': ']', '{': '}'}for char in string:if char in brackets: # 左括号入栈stack.push(char)elif char in brackets.values(): # 右括号与栈顶元素匹配if stack.is_empty():return Falseif brackets[stack.peek()] == char:stack.pop()else:return Falsereturn stack.is_empty()# 测试用例test_cases = ["()", "{[]}", "[{()}]", "(}", "{[}]"]for test_case in test_cases:if bracket_match(test_case):print(test_case, "匹配成功")else:print(test_case, "匹配失败")实验结果:运行测试用例,可以得到以下结果:- "()" 匹配成功- "{[]}" 匹配成功- "[{()}]" 匹配成功- "(}" 匹配失败- "{[}]" 匹配失败实验讨论:根据实验结果,我们可以看到算法能够正确地检测出括号的匹配情况。

括号匹配实验报告

括号匹配实验报告

括号匹配实验报告实验报告课程名称:数据结构班级:实验成绩:实验名称:栈、队列、字符串和数组学号:批阅教师签字:实验编号:实验⼆姓名:实验⽇期:指导教师:组号:实验时间:⼀、实验⽬的(1)掌握栈、队列、串和数组的抽象数据类型的特征。

(2)掌握栈、队列、串和数组的抽象数据类型在计算机中的实现⽅法。

(3)学会使⽤栈、队列来解决⼀些实际的应⽤问题。

⼆、实验内容与实验步骤(1)实验内容:假设表达式中除了变量名、常量和运算符外,还可以允许两种括号:圆括号和中括号,其嵌套的次序随意,编写程序检验输⼊的表达式中括号的的顺序是否合法。

(2)描述抽象数据类型或设计的函数描述,说明为什么要使⽤这种抽象数据类型,并说明解决设想。

抽象数据类型或函数描述:⾸先定义了⼀个结构体并且声明为栈类型,在其中定义了空间基地址的指针、栈顶指针以及栈存储空间的⼤⼩。

之后设计了Creat _Stack的函数,⽤此函数来创建⼀个空栈,这样可以使⽤堆栈来实现括号匹配的功能,⼜设计了⼀个名为Stack_Full的函数了来判断栈是否已满,若栈未满才可继续之后的压栈功能,如果堆栈已满,则需要使⽤realloc来动态分配空间,扩⼤栈的存储空间。

我还设计了⼀个名为empty的函数,⽤它来判断堆栈是否为空,堆栈为空或不为空时分别返回0或1。

之后设计了名为push和pop的函数来实现括号的⼊栈和出栈,之后设计了名为Match的函数,来判断括号是否匹配,设计了名为clean的函数来清空堆栈,这样可以连续判断不同的多项式的括号是否匹配。

解决设想:对于本题,⾸先我使⽤了栈结构,利⽤栈中数据“先进后出”的特点来实现对括号是否匹配的检验。

实现过程基本如下:从左到右依次扫描多项式,如果遇到左括号便将左括号⼊栈,在所有左括号⼊栈之后便可以扫描到右括号,如果扫描到的右括号和栈顶的左括号可以匹配时,将左括号出栈,以此类推,最后判断栈是否为空,若为空,则括号匹配,否则括号不匹配。

括号匹配检测实验报告(3篇)

括号匹配检测实验报告(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)}")```四、实验结果与分析通过上述代码,我们对一系列测试用例进行了括号匹配检测。

数据结构实验报告:括号匹配问题

数据结构实验报告:括号匹配问题

●实验内容:利用栈的基本操作,写一个C程序实现检测表达式“@{(a+b)*[c-d]+e}+f”中的括号是否匹配。

●实验目的:掌握栈的操作●提交内容:C语言源代码:#include <stdio.h>#include <string.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top;}SeqStack;int InitStack(SeqStack *s){s->top=-1;return 1;}int Push(SeqStack *s,ElemType x){if (s->top == MaxSize -1 ){printf("栈已满,不能入栈.\n");return 0;}else{s->top++;s->data[s->top] = x;}return 1;}int Pop(SeqStack *s,ElemType *x) {if (s->top == -1){printf("栈为空,不能出栈.\n");return 0;}else{*x=s->data[s->top];s->top--;}return 1;}int GetTop(SeqStack *s,ElemType *x) {if (s->top == -1){printf("栈为空,不能取值.\n");return 0;}else{*x=s->data[s->top];}return 1;}int IsEmpty(SeqStack *s) {if(s->top==-1)return 1;return 0;}int Check(char str[],int len) {int i;int a=1,b=0;ElemType x;SeqStack s;InitStack(&s);for(i=0;i<len;i++){if(str[i]=='{'){if(IsEmpty(&s)){if(Push(&s,str[i])!=1){a=0;break;}}else{if(GetTop(&s,&x)!=1){a=0;break;}if(x=='{' || x=='[' || x== '('){a=0;break;}else{if(Push(&s,str[i])!=1){a=0;break;}}}}else if(str[i]=='['){if(IsEmpty(&s)){if(Push(&s,str[i])!=1){a=0;break;}}else{if(GetTop(&s,&x)!=1){a=0;break;}if(x=='[' || x== '('){a=0;break;}else{if(Push(&s,str[i])!=1){a=0;break;}}}}else if(str[i]=='('){if(Push(&s,str[i])!=1){a=0;break;}b=1;}else if(str[i]==')'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='('){a=0;break;}}else if(str[i]==']'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='['){a=0;break;}if(b==0){a=0;break;}}else if(str[i]=='}'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='{'){a=0;break;}if(b==0){a=0;break;}}elsecontinue;}if(!IsEmpty(&s))a=0;return a;}int main(){char str[MaxSize];int i,len;printf("输入字符串:\n");gets(str);len=strlen(str);if(Check(str,len)==0)printf("匹配合法\n");elseprintf("匹配不合法\n");。

数据结构实验报告(栈

数据结构实验报告(栈

数据结构实验报告(栈
一、实验名称
栈的实现及应用
二、实验目的
1.了解栈的概念与基本操作。

2.掌握栈的基本实现(栈的存储结构、栈的主要操作和栈的应用)。

3.通过编写程序实现栈的基本操作和应用。

三、实验内容
1.栈的定义:栈是一种具有特定结构的数据类型,其特殊之处在于只能从固定的一端(称为栈顶)进行插入,删除和查找操作。

2.栈的存储结构:栈既可以采用顺序存储结构,也可以采用链式存储结构。

3.栈的基本操作有:进栈(push)、出栈(pop)、查看栈顶元素(get_top)、清空栈(clear)、获取栈长度(length)等。

4.栈的应用:主要用于表达式求值、括号匹配、逆序输出等操作。

五、实验步骤
2.编写程序实现栈结构的创建、进栈、出栈、查看栈顶元素、清空栈、获取栈长度等基本操作。

四、实验结果
1.按照实验要求,成功创建一个栈的数据结构,并实现栈的基本操作。

栈作为常用的一种数据结构,在实际的编程中有广泛的应用。

通过本次实验的学习,对栈的概念、特点、实现方式有了更深刻的了解,同时也掌握了栈的一些应用操作,这对于提高代码效率和解决实际问题有很大的帮助。

数据结构括号配对问题(栈)

数据结构括号配对问题(栈)

实验报告课程名称:数据结构年级班级:计算机1712学号姓名:查玉坤 ********** 任课教师:***实验六、括号匹配算法的实现一、实验目的1)了解栈的存储结构及基本操作;2)了解队的存储结构与基本操作;3)了解栈和队的简单运用。

二、实验工具C-Free5三、实验练习和要求1、实验内容:1)分别建一个栈和队的结构;2)通过扫描,将含有大,中,小括号的测试字符串中的非括号字符过滤掉;3)利用栈来判断字符串中的大,中,小括号是否是匹配的。

实验要求:1)含有大,中,小括号的字符串测试用例要有多组(尽量包括各种情况);2、实验难点:1)如何判断某种括号的匹配性;2)如何判断是括号或是某种括号;3)栈和队的具体实现。

3、实现提示1)通过对字符是否属于串“()[]{}”来过滤是否是括号;2)利用括号的匹配的特点(第一个右与最后一个左来匹配)来进行匹配性判断,三种括号分别匹配;3)可利用括号在字符串“()[]{}”中的位置来进行匹配判断;4、注意事项测试用例要丰富(至少四组:不配/少左/少右/成功),返回结果要清楚。

5、在运行结果中加入自己的姓名学号和自己学位下一位同学的学号和姓名。

四、实验内容实验代码如下:#include<stdio.h>#include<stdlib.h>#define INITSIZE 100typedef char ElemType;typedef struct node{ElemType data;struct node *next;}slink;typedef struct{ int top;ElemType *base;int stacksize;}sqstack;//创建空链表slink *creslinkemp(){ slink *head,*p;p=head=(slink *)malloc(sizeof(slink));p->next=NULL;return head;}//输出链表void List(slink *head){ slink *p;p=head->next;while(p!=NULL){ printf(" %c",p->data);p=p->next;}printf("\n");}/*初始化操作(创建一个空栈S)*/void initstack(sqstack *S){ S->base=(ElemType *)malloc(INITSIZE*sizeof(ElemType)); S->top=0;S->stacksize=INITSIZE;}int gettop(sqstack *S,ElemType *e){ if(S->top==0) return 0;*e=S->base[S->top-1];return 1;}/*入栈操作(将值为x的数据元素插入到栈S中,使之成为栈顶元素)*/ int push(sqstack *S,ElemType x){ if(S->top>=S->stacksize){ S->base=(ElemType *)realloc(S->base,(S->stacksize+1)*sizeof(ElemType));if(!S->base) return 0;S->stacksize++;}S->base[S->top++]=x;return 1; }/*出栈操作(取出栈S的栈顶元素)*/int pop(sqstack *S,ElemType *e){ if(S->top==0) return 0;*e=S->base[--S->top];return 1;}/*判栈空操作(判断栈S是否为空)*/int emptystack(sqstack *S){ if(S->top==0) return 1;else return 0;}/*输出栈操作(输出自栈顶到栈底的元素值)*/void list(sqstack *S){ int i;for(i=S->top-1;i>=0;i--)printf("%c ",S->base[i]);}int strch(char KH[],char ch){for(int i=0;i<6;i++){if(KH[i]==ch) return 1;}return 0;}//判断左右括号int LORR(slink *p){if(p->data=='('||p->data=='['||p->data=='{') {return 1;}else return 0;}//返回配对的括号char match(char K){char R;switch(K){case '(':{R=')';break;}case '[':{R=']';break;}case '{':{R='}';break;}case ')':{R='(';break;}case ']':{R='[';break;}case '}':{R='{';break;}default:{break;}}return R;}int main(){char KH[7]="(){}[]";char ch,x;slink *KUOHAO=creslinkemp();slink *p=KUOHAO,*s;sqstack Lbracket;initstack(&Lbracket);printf("输入式子:\tCtrl+z结束输入\n");while(scanf("%c",&ch)!=EOF){if(strch(KH,ch)) {s=(slink *)malloc(sizeof(slink));s->data=ch;s->next=NULL;p->next=s;p=s;}}printf("\n所有括号为:");List(KUOHAO);printf("\n");p=KUOHAO->next;while(p!=NULL){if(LORR(p)){ //若为左括号,压栈push(&Lbracket,p->data);p=p->next;}else { //若为右括号gettop(&Lbracket,&x);if(emptystack(&Lbracket)) {printf("结果:缺少左括号%c\n\n",match(p->data));printf("查玉坤2017116128\n");printf("下一位同学:余晓敏2017117242\n");return 0;}else if(x==match(p->data)){pop(&Lbracket,&x);p=p->next;}else{printf("结果:括号种类不配对!\n\n");printf("查玉坤2017116128\n");printf("下一位同学:余晓敏2017117242\n");return 0;}}}gettop(&Lbracket,&x);if(!emptystack(&Lbracket)){printf("结果:缺少右括号%c\n\n",match(x));}else printf("结果:括号匹配正确!\n\n");printf("查玉坤2017116128\n");printf("下一位同学:余晓敏2017117242\n");return 0;}运行结果:例1: 例2:例3: 例4:五、疑难问题的解决和感想错误:由于while循环中套用了较多if条件句,使用括号较多,导致程序最后少了一个“}”。

数据结构括号匹配实验报告

数据结构括号匹配实验报告

括号的匹配1.需求和规格说明(1)实现括号的是否匹配的判定。

(2)实现匹配错误的提示。

(3)实现栈内容的动态显示。

2.设计2.1.设计思想(1)对于括号匹配的判定,首先输入字符串到缓冲区。

逐个字符读取字串,遇到的是左括号则入栈,若是右括号,则出栈。

出栈的左括号如果和右括号匹配,则一对括号匹配成功;否则,这对括号匹配失败,并给出错误提示。

(2)分析括号匹配错误出现的情况,主要有三种:左括号数大于右括号数,左括号与右括号不匹配,右括号数大于左括号数。

根据栈的存储情况就能判定出这三种情况,并且实时的将信息放映到可视化控件上。

(3)对于匹配过程和栈内容的动态显示,可以用listbox控件实时的显示和更新。

窗口上有两个listbox控件,第一个动态显示push和pop动作以及提示错误信息;第二个listbox则动态模拟栈内的存储情况。

2.2.设计表示(1)存储结构Node节点template <class element>class Node{public:element ele;Node *pre; //前驱指针Node *next; //后继指针Node(){pre=NULL;next=NULL;}Node(element e){ele=e;pre=NULL;next=NULL;}Node * MakeNode(element e)//传入参数返回一个节点指针,实现参数的封装。

{Node<element> *temp=new Node(e);return temp;}};MyListStack链栈template <class element>class MyListStack{public:Node<element> *base;Node<element> *top;int index;MyListStack() //初始化链表{base=new Node<element>();top=base;index=0;}void push(element n) //push{Node<element> *temp=new Node<element>(n);top->next=temp;temp->pre=top;top=temp;index++;}void pop(element & out) //pop{out=top->ele;top=top->pre;delete top->next;top->next=NULL;index--;}BOOL isEmpty(); //返回栈是否为空{if(index)return FALSE;elsereturn TRUE;}virtual ~MyListStack() //析构链栈,释放空间。

数据结构栈实验报告

数据结构栈实验报告

一、实验目的本次实验旨在帮助学生掌握栈的基本概念、特点、逻辑结构以及抽象数据类型,熟练运用顺序栈和链栈进行基本操作,理解递归算法中栈的状态变化,并学会在计算机科学中应用栈解决实际问题。

二、实验内容1. 实现顺序栈和链栈的结构类型定义、特点以及基本操作的实现。

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

3. 设计算法,利用栈操作将指定栈中的内容进行逆转。

4. 实现求解整数数组最大值的递归算法。

5. 分析实验过程中遇到的问题及解决方法。

三、实验步骤1. 实现顺序栈和链栈(1)顺序栈顺序栈使用数组实现,具有以下特点:- 存储空间固定,栈的大小预先定义。

- 栈顶指针指示栈顶元素的位置。

- 入栈和出栈操作都在栈顶进行。

- 当栈满时,无法继续入栈。

- 当栈空时,无法继续出栈。

(2)链栈链栈使用链表实现,具有以下特点:- 栈的大小可变,不受存储空间限制。

- 栈顶指针指向栈顶元素的前一个节点。

- 入栈和出栈操作的时间复杂度为O(1)。

- 不存在栈满或栈空的情况。

2. 编写算法判断字符序列是否为回文(1)创建一个空栈。

(2)遍历字符序列,将每个字符依次入栈。

(3)遍历字符序列,将每个字符依次出栈,并判断出栈的字符是否与原序列中的字符相同。

(4)若所有字符均相同,则字符序列为回文;否则,不是回文。

3. 设计算法,利用栈操作将指定栈中的内容进行逆转(1)创建一个空栈。

(2)遍历原栈,将每个元素依次出栈,并判断栈是否为空。

(3)若栈不为空,则将出栈的元素依次入栈。

(4)当原栈为空时,将新栈中的元素依次出栈,实现栈内容的逆转。

4. 实现求解整数数组最大值的递归算法(1)定义一个递归函数,用于求解数组中最大值。

(2)在递归函数中,比较当前元素与左右子数组中的最大值。

(3)返回最大值。

5. 分析实验过程中遇到的问题及解决方法(1)问题:顺序栈在栈满时无法继续入栈。

解决方法:在入栈操作前,判断栈的大小是否已满。

若已满,则提示用户栈已满,无法继续入栈。

实验报告栈序列匹配

实验报告栈序列匹配

实验报告栈序列匹配1. 引言栈是计算机科学中常用的一种数据结构,它具有先进后出(LIFO)的特点。

在实际应用中,栈常常用于括号匹配、表达式计算等方面,起到关键的作用。

本实验将主要研究栈在括号匹配方面的应用。

我们将实现一个算法,用于判断给定字符串中的括号是否匹配。

2. 算法设计我们将使用栈来进行字符串的括号匹配。

具体算法如下:1. 初始化一个空栈。

2. 从左到右遍历字符串中的每一个字符。

3. 如果当前字符是左括号(包括小括号、中括号和大括号),则将其压入栈中。

4. 如果当前字符是右括号,则判断栈是否为空。

- 如果栈为空,则说明右括号没有对应的左括号,匹配失败,返回错误。

- 如果栈不为空,则从栈顶取出一个字符。

- 如果该字符不是对应的左括号,匹配失败,返回错误。

- 如果该字符是对应的左括号,继续遍历下一个字符。

5. 如果遍历结束后栈为空,则说明所有括号都能够匹配,匹配成功;否则匹配失败。

3. 算法实现我们使用Python编程语言来实现以上算法,具体代码如下:pythondef match_parentheses(string):stack = []parentheses_dict = {')': '(', ']': '[', '}': '{'}for char in string:if char in '([{':stack.append(char)elif char in ')]}':if not stack:return Falseif stack[-1] == parentheses_dict[char]:stack.pop()else:return Falsereturn not stack4. 实验结果为了验证算法的正确性,我们对几组测试样例进行了测试。

样例1:输入字符串为"({})[]",预期输出为True。

括号匹配问题 栈c语言实验报告

括号匹配问题 栈c语言实验报告

括号匹配问题栈c语言实验报告
一、实验目的
(1)掌握用C语言调试程序的基本方法。

(2)掌握栈的基本定义及其存储实现。

(3)掌握栈的常见算法的程序实现。

(4)掌握栈在实际问题背景下的灵活应用。

二、实验内容
算术表达式中右括号和左括号匹配的次序正好符合后到括号要最先被匹配的“后进先出”堆栈操作特点,因此可以借用一个堆栈来进行判断。

具体方法:
⑴顺序扫描算术表达式(表现为一个字符串);
⑵当遇到三种类型的左括号时,让该括号进栈;
⑶当遇到某一种类型的右括号时,比较当前栈顶括号是否与之匹配,
⑷若匹配则退栈,转(1)继续进行判断;
⑸若不匹配,则左右括号配对次序不正确,结束。

⑹若字符串当前为某一类型的右括号而堆栈为空,则右括号多于左括号,结束。

⑺若字符串扫描结束而堆栈非空,则左括号多于右括号,结束。

⑻若字符串扫描结束而堆栈为空,则左右括号匹配正确,结束。

三、实验要求
(1)程序要添加适当的注释,程序的书写要采用缩进格式。

(2)程序要具备一定的健壮性,即当输入数据非法时,程序也能适当地做出反应。

(3)程序要做到界面友好,在程序运行时用户可以根据相应的提示信息进行操作。

(4)根据实验报告模板详细书写实验报告(程序调试成功的,需将运行结果截图附在实验报告里面;实验报告以pdf格式或者.doc格式/.docx格式上传)。

(5)将源程序(.c或者.cpp)压缩为一个文件(如果自定义了读、写文件则一起压缩)上传,扩展名为:.rar或.zip。

四、实验环境
Windows 10,Microsoft Visual C++2010 Express。

栈序列匹配 数据结构 实验报告

栈序列匹配 数据结构 实验报告

数据结构实验报告实验题目:栈序列匹配班级:信息与计算科学111 **:**学号: ******** 完成日期: 2012.11.26一、需求分析(说明实验的任务,包括输入、输出、功能、测试数据等)1.对于给出的入栈序列和出栈序列,判断这两个序列是否相容。

即能否利用栈操作将入栈序列转换为出栈序列。

2.入栈序列和出栈序列均为不含空格的字符型数据,由键盘输入,其长度不超过10个字符。

若入栈序列和出栈序列相容(即能利用栈操作将入栈序列转换为出栈序列),则输出yes,否则输出no。

并在判断栈序列的匹配过程中,输出入栈、出栈的过程和栈中的元素。

3.输入数据的第一行为一个正整数T, 表示测试数据的组数。

然后是T组测试数据。

每组测试数据的输入是在同一行中用一个空格分隔的两个字符串(其长度均不超过10),依次表示入栈序列和出栈序列。

4.输出格式为每入栈(或)出栈一次输出一行:push(或pop):c stack:栈顶到栈底的序列,其中c为入栈(或)出栈的字符,最后一行个根据入栈序列和出栈序列是否匹配输出yes或no,匹配则输出yes,否则输出no。

二、概要设计(数据类型的定义、算法思想、主程序和子程序(或功能)模块的说明及各程序模块之间的层次(调用)关系)算法思路:设置链式栈或顺序栈s,作为入栈序列的栈空间,设置栈顶指针(或下标)。

对入栈序列从第一个元素开始考虑入栈,在依次扫描出栈序列元素的过程中进行如下的处理:若栈空且入栈序列有未入栈的元素,则当前入栈序列中的元素入栈,并输出相应的信息;若栈不空且栈顶的元素为出栈序列的当前元素,则栈顶元素出栈,并输出相应的信息,否则,若入栈序列有未入栈的元素,则当前入栈序列中的元素入栈,并输出相应的信息;否则可以确定输入的入栈序列和出栈序列不相容(即不匹配)。

1、栈的抽象数据类型定义struct stacknode //链式栈s中的结点结构{……};typedef struct stacknode stacknode,*linkstack;int push(linkstack *top,char e) 入栈顺序{……}int pop(linkstack *top, char *e) 出栈顺序{……}2、判断入栈序列和出栈序列是否匹配int judge(char a[],char b[]){linkstack p=NULL;……}3、列出入栈出栈的顺序void list(linkstack s){……}4、主程序的处理流程int main() //主函数{输入入栈顺序和出栈顺序;判断入栈和出栈序列是否相容输出结果}三、详细设计(实现概要设计中定义的数据类型,对主程序和其他模块写出算法,说明子模块的调用关系)struct stacknode //链式栈s中的结点结构{char data;struct stacknode *next;};typedef struct stacknode stacknode,*linkstack;void list(linkstack s); //显示栈中元素int push(linkstack *top,char e) // 入栈操作{stacknode *s;s=(stacknode *)malloc(sizeof(stacknode));s->data=e;s->next=*top;*top=s;return 1;}int pop(linkstack *top, char *e) // 出栈操作{linkstack p;if(*top==NULL) return 0;*e=(*top)->data;p=*top;*top=(*top)->next;free(p);return 1;}int judge(char a[],char b[]) //对是否相容进行判断{linkstack p=NULL;char e; //栈顶元素int i=0,j=0 ; //入栈顺序下标出栈顺序下标while(i<strlen(a)){printf("push:");push(&p,a[i]);printf("%c\n",p->data);i++;while(p!= NULL && p->data==b[j]){printf("pop:");printf("%c\n",p->data);pop(&p,&e);list(p);j++;}}if( p==NULL ) return 1;else return 0;}void list(linkstack s) //列出栈内元素{linkstack p;p=s;printf("stack:");while(p){printf("%c ",p->data);p=p->next;}printf("\n");}//主函数int main(){char a[50],b[50]; //定义入栈顺序和出栈顺序输入实验组数twhile(t--){gets(a); //输入入栈顺序gets(b); //输入出栈顺序flag=judge(a,b); //判断是否相容if(flag==1) printf("YES\n");else printf("NO\n"); //返回值 yes no }return 0;}四、调试分析(调试过程中遇到的问题是如何解决的、对设计与实现简要回顾或分析、经验和体会、经验和不足等,至少写三条)●在设计这个程序中,我遇到一个困难就是,当我输入组数2,按回车键之后,输入入栈顺序和出栈顺序就出现在同一行里面,导致不能输入,经过反复实验和查资料,最终将问题解决。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构课程设计报告
设计题目:括号匹配
院系计算机学院
年级11 级
学生刘云飞
学号E01114295
指导教师王爱平
起止时间9-7/9-14
课程设计目的
1.熟悉并写出栈的逻辑结构表示
2.实现栈的存储表示
3.实现栈的操作
内容
括号匹配
课程设计要求
1.在实验报告中写出栈的ADT表示;
2.在实验报告中给出数据类型定义和核心算法和程序;
3.在实验报告中罗列实验过程中出现的问题和解决的方法;
4.打包上交调试后的完整程序,提交实验报告;
5.实验之前写出实验报告的大概框架,实验过程中填写完整。

6.实验时携带需要上机调试的程序;
7.实验评分:实验之前预习占20%,实验报告书写情况占50%,运行情况30%。

概要设计
1.栈的ADT表示
ADT Stack{
数据对象:D={ai|ai∈ ElemSet,i=1,2,…,n,n>=0}
数据关系:R1={<ai-1,ai>|ai-1,ai ∈D,i=2,…,n}
约定an为栈顶端,a1为栈底端
基本操作:
Status InitStack(&s)
操作结果:构造一个空栈s。

Status Push( &s, e)
初始条件:栈s已经存在。

操作结果:插入元素e为新的栈顶元素。

Status Pop( &s, &e)
初始条件:栈s已经存在,并不为空。

操作结果:删除s的栈顶元素,并用e返回其值。

Status Check( &s, e)
初始条件:栈s已经存在,并不为空。

操作结果:判断括号是否匹配。

Status EnterString( &s)
}ADT Stack
2.数据类型定义和核心算法和程序
数据类型定义:
typedef int Status;
typedef char SElemType;
typedef struct {//栈的顺序存储表示
SElemType* base;
SElemType* top;
int stacksize;
}SqStack;
int x=0;
SElemType a;
SElemType e;
✧核心算法:
✧程序:
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define TURE 1
#define FALSE 0
#define ERROR 0
#define OK 1
#define INFEASIBLE -1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef char SElemType;
typedef struct {//栈的顺序存储表示
SElemType* base;
SElemType* top;
int stacksize;
}SqStack;
int x=0;
Status InitStack(SqStack &s){//构造一个空栈S
s.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
if (!s.base) exit(OVERFLOW);//内存分配失败
s.top = s.base;
s.stacksize = STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack &s,SElemType e){
//插入元素e为新的栈顶元素
if(s.top-s.base>=s.stacksize){
//栈满追加存储空间。

s.base = (SElemType*)realloc(s.base,(s.stacksize+
STACKINCREMENT)*sizeof(SElemType));
if(!s.base) exit(OVERFLOW);//内存分配失败
s.top = s.base+s.stacksize;
s.stacksize += STACKINCREMENT;
}
*s.top++ =e;
return OK;
}
Status Pop(SqStack &s,SElemType &e){
//若栈不空,则删除s的栈顶元素,用e返回其值,并返回ok;否则返回error。

if(s.top == s.base) return ERROR;
e = * --s.top;
return OK;
}
//////////////////////////////////////////////////////////////////// Status Check(SqStack &s,SElemType e){
SElemType a;
Pop(s,a);
if( a=='(' && e==')' ||
a=='['&& e==']' ||
a=='{'&& e=='}' )
return TURE;
return ERROR;
}
Status EnterString(SqStack &s){
SElemType e;
while (1){
scanf("%c",&e);
if(e=='('||e=='['||e=='{')
Push(s,e);
else if(e==')'||e==']'||e=='}'){
if(!Check(s,e)){
return FALSE;
break;}
}
else if(e!='\n'){
x=1;
return FALSE;
break;
}
else
break;
}
}
void main()
{
system("cls");
system("color 1f");
printf("\n@=========================================================@\n");
printf("| *********欢迎进入括号匹配系统************* |\n");
printf("| 姓名:刘云飞学号:E01114295 |\n");
printf("@_________________________________________________________@\n");
SqStack s;
InitStack(s);
if(EnterString(s))
printf("括号匹配\n");
else if(x==1)
printf("输入的不是括号\n");
else
printf("括号不匹配\n");
}
【实验结果】。

相关文档
最新文档