圆括号是否正确配对

【问题描述】

设计一个算法判别一个算术表达式的圆括号是否正确配对

【输入形式】

一个任意字符串表达式

【输出形式】

若配对，则输出圆括号的对数；否则输出no

【样例输入】(a+b)/(c+d)@

【样例输出】 2

【样例说明】共有两对括号，输出2

【评分标准】

使用栈相关知识，否则不能得分

主函数

#include"_STACK_H_.h"

int main(void)
{
	Stack_Order stack;
	Stack_Order stack1;
	Stack_Order stack2;
	PStack pstack;
	PStack pstack1;
	PStack pstack2;
	pstack = &stack;
	pstack1 = &stack1;
	pstack2 = &stack2;
	char x;
	int longs=0;
	Order_Create_Stack(pstack);
	Order_Create_Stack(pstack1);
	Order_Create_Stack(pstack2);
	if (Order_Stack_Judgment==false)
	{
		printf("内存不足，再见！");
		exit(1);
	}
	while (scanf("%c", &x)!=EOF)
	{
		Order_Stack_Push(pstack, &x);
	}
	while (Order_Stack_Judgment(pstack) == false)
	{
		Order_Stack_Pop(pstack, &x);
		if (x == '(')
		{
			Order_Stack_Push(pstack1, &x);
		}
		else if (x == ')')
		{
			Order_Stack_Push(pstack2, &x);
		}
	}
	if (Order_Stack_Long(pstack1)==Order_Stack_Long(pstack2)&& Order_Stack_Long(pstack1)!=0)
	{
		if (Order_Stack_Judgment(pstack1) == false)
		{
			if (Order_Stack_Judgment(pstack2) == false)
			{
				longs = Order_Stack_Long(pstack2);
				printf("%d", longs);
			}
		}
	}
	else
	{
		printf("no");
	}
	return 0;
}

头文件

#ifndef _STACK_H_
#define _STACK_H_

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>

/*特殊量定义区*/

//栈的数据类型
#define Data_Type char

//顺序栈的大小
#define Data_Size 20

/*结构体定义区*/

//数据域结构体
typedef struct Data
{
	Data_Type data[Data_Size];
	int stack_top;
}Stack_Order;

typedef Stack_Order* PStack;
/*函数声明区*/

//操作：	创建一个空栈
//前置条件：传入一个栈的指针
//后置条件：如果创建成功返回true,否则返回false
bool Order_Create_Stack(PStack pstack);

//操作：	把一个栈置为空栈
//前置条件：传入一个栈的指针
//后置条件：如果创建成功返回true,否则返回false
bool Order_Stack_Empty(PStack pstack);

//操作：	判断栈是否为空栈
//前置条件：输入一个栈的地址
//后置条件：如果栈为空返回true,否则返回false
bool Order_Stack_Judgment(PStack pstack);

//操作：	返回栈的长度 
//前置条件：输入一个栈的地址
//后置条件：返回栈的长度
int Order_Stack_Long(PStack pstack);

//操作：	插入一个元素data为栈顶元素
//前置条件：输入一个栈的地址，和插入元素的地址
//后置条件：插入成功返回true,否则返回false
bool Order_Stack_Push(PStack pstack,Data_Type* data);

//操作：	弹出栈顶元素
//前置条件：输入一个栈的地址，一个栈数据类型data的地址
//后置条件：将栈顶数据交给data，删除栈顶元素，成功返回true,否则返回false
bool Order_Stack_Pop(PStack pstack,Data_Type* data);

//操作：	输出栈顶元素
//前置条件：输入一个栈的地址，一个栈数据类型data的地址
//后置条件：成功返回true,否则返回false
bool Order_Stack_GetTop(PStack pstack, Data_Type* data);

//操作：	从栈底到栈顶依次对栈中每个元素显示 
//前置条件：输入栈的地址
void Order_Stack_Print(Stack_Order stack);

//操作：	打印当前数据
//前置条件：输入当前数据
void Order_Stack_visit(Data_Type data);


#endif // !_STACK_H_

引用函数

#include"_STACK_H_.h"

bool Order_Create_Stack(PStack pstack)
{
	pstack->stack_top = -1;
	return true;
}

bool Order_Stack_Empty(PStack pstack)
{
		pstack->stack_top = -1;
		return true;
}

bool Order_Stack_Judgment(PStack pstack)
{
	if (pstack->stack_top == -1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int Order_Stack_Long(PStack pstack)
{
	return (pstack->stack_top) + 1;
}

bool Order_Stack_Push(PStack pstack,Data_Type* data)
{
	if (pstack->stack_top == Data_Size - 1) 
	{
		return false;
	}
	else
	{
		pstack->stack_top++;
		pstack->data[pstack->stack_top]=*data;  
		return true;
	}
}

bool Order_Stack_Pop(PStack pstack, Data_Type* data)
{
	if (pstack->stack_top==-1)
	{
		return false;
	}
	else
	{
		*data = pstack->data[pstack->stack_top];
		pstack->stack_top--;
		return true;
	}
}

void Order_Stack_Print(Stack_Order stack)
{
	int i;
	i = 0;
	while (i <=stack.stack_top)
	{
		Order_Stack_visit(stack.data[i++]);
	}
	printf("\n");
}

void Order_Stack_visit(Data_Type data)
{
	printf("%d ",data);
}

bool Order_Stack_GetTop(PStack pstack, Data_Type* data)
{
	if (pstack->stack_top == -1)
	{
		return false;
	}
	else
	{
		*data = pstack->data[pstack->stack_top];
		return true;
	}
}