一、题目

请编写程序检查C语言源程序中下列符号是否配对：/* 与 */、( 与 )、[ 与 ]、{ 与 }。

输入格式:
输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。

输出格式:
首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少右符号，则输出左符号-?。

输入样例1：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) { /*/
        A[i] = i;
}
.

输出样例1：

NO
/*-?

输入样例2：

void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /**/
        A[i] = i;
}]
.

输出样例2：

NO
?-]

输入样例3：

void test()
{
    int i
    double A[10];
    for (i=0; i<10; i++) /**/
        A[i] = 0.1*i;
}
.

输出样例3：

YES

二、思路

1.考查栈。
利用栈进行左右符号匹配。核心思想：首先读入一系列左半符，当读到一个右半符时，将其与最后一个读到的左半符匹配：若匹配成功就可以消去一对，否则报错。根据错误情况不同，将报错分为不同的类型（缺失左半符、缺失右半符），而不同的“错误类型”会影响到不同的输出格式。

2.怎样判断每一个读入的字符属于什么类型？
用enum列出所有需要处理的字符串类型，并将之命名为token类型。enum可以枚举一系列常量。
typedef enum { ret=0, lc=1, lbrc=2, lbrkt=3, lpr=4, rc=5, rbrc=6, rbrkt=7, rpr=8, others=9 } token;
各符号分别代表：
ret：空格
lc、lbrc、lbrkt、lpr：/*、{、[、（
rc、rbrc、rbrkt、rpr：与左半符依次对应
others：其他字符

3.怎么判断左右两个字符是否匹配？
有了上述enum的定义（注意变量枚举顺序，左右半符必须一致），就比较简单了。能相互匹配的左右字符之间的间距是一样的。也就是说只要满足右-左=4，就一定是匹配的。

三、代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAXN 100;

typedef enum {
     ret=0, lc=1, lbrc=2, lbrkt=3, lpr=4, rc=5, rbrc=6, rbrkt=7, rpr=8, others=9 } token;
/* enum用来枚举常量，这里各符号分别代表：
 ret：空格
 lc、lbrc、lbrkt、lpr：/*、{、[、（
 rc、rbrc、rbrkt、rpr：与左半符依次对应
 others：其他字符
以上符号统一命名为token类型 */

typedef token ElementType;

//定义堆栈
typedef int position;
typedef struct SNode* PtrToSNode;
struct SNode {
    
	ElementType* data;
	position top;
	int maxsize;
};
typedef PtrToSNode stack;

//函数声明
stack CreateStack(int maxsize);
bool IsEmpty(stack S);
void push(stack S, ElementType x);
void pop(stack S);
ElementType peek(stack S);
int check(token* t1, token* t2);
bool IsEnd(int newline, char* c);//判断读入是否结束
token getoken(char c);//返回字符类型,即把输入的字符对应到自定义的类型上去。
bool IsPaired(token t1, token t2);
void PrintS(token t);

//主程序
int main() {
    
	token t1, t2;
	int error = check(&t1, &t2);

	if (!error) printf("YES\n");
	else {
    
		printf("NO\n");
		switch (error) {
    
		case 1:
			printf("?-");
			PrintS(t1);
			break;
		case 2:
			PrintS(t2);
			printf("-?");
			break;
		default:break;
		}

		printf("\n");
	}

	return 0;
}


//创建空栈
stack CreateStack(int maxsize) {
    
	stack S = (stack)malloc(sizeof(struct SNode));
	S->data = (ElementType*)malloc(maxsize * sizeof(ElementType));
	S->top = -1;
	S->maxsize = maxsize;
	return S;
}

//判断栈是否为空
bool IsEmpty(stack S) {
    
	return (S->top == -1);
}

//入栈
void push(stack S, ElementType x) {
    
	S->data[++(S->top)] = x;
}

//出栈
void pop(stack S) {
    
	(S->top)--;
}

//找到栈首元素
ElementType peek(stack S) {
    
	return(S->data[S->top]);
}


//符号配对
int check(token* t1, token* t2) {
    
	stack S; //检测匹配用的堆栈
	char c; //存读入的字符
	token t; //存字符转换后的类型
	int newline; //标识当前是否为新的一行
	int error; //标识错误

	S = CreateStack(100);
	newline = 1;
	error = 0;
	while (1) {
    
		scanf_s("%c", &c);
		if (IsEnd(newline, &c)) break; //如果已经读到结尾，则跳出循环
		else {
    
			switch (t = getoken(c)) {
    /*解析当前字符c的类型*/
			case lc:
			case lbrc:
			case lbrkt:
			case lpr:
				push(S, t);
				newline = 0;
				break;//如果识别到是左半符，则入栈，当前行不再是新行
			case rc:
			case rbrc:
			case rbrkt:
			case rpr:
				if (IsEmpty(S)) error = 1; //如果栈为空，说明缺失左半符
				else if (!IsPaired(t, peek(S))) error = 2; //栈不为空，但与栈顶元素不匹配（左右半符不是一对）
				else pop(S);//匹配成功
				newline = 0;
				break;
			case ret:newline = 1; break;//遇到回车就标识新的一行
			default:newline = 0; break;//其他字符跳过不处理
			}

			if (error) break;
		}
	}

	if (!error && !IsEmpty(S)) error = 2;
	(*t1) = t;
	(*t2) = peek(S);

	return error;

}


bool IsEnd(int newline, char* c) {
    
	/*判断读入是否结束*/
	if (newline && (*c) == '.') {
    
		scanf_s("%c", c);
		if ((*c) == '\n') {
    
			return true;
		}
		else return false;
	}
	else return false;
}

//返回字符的类型
token getoken(char c) {
    
	switch (c) {
    
	case '\n':return ret;
	case '{':return lbrc;
	case '[':return lbrkt;
	case '(':return lpr;
	case '/':
		scanf_s("%c", &c);
		if (c == '*') return lc;
		else return getoken(c);
	case '}':return rbrc;
	case ']':return rbrkt;
	case ')':return rpr;
	case '*':
		scanf_s("%c", &c);
		if (c == '/') return rc;
		else return getoken(c);
	default:return others;

	}
}

//判断是否匹配
bool IsPaired(token t1, token t2)
{
    
	return t1 - t2 == 4; /*如果enum差值是4，说明是匹配的。*/
}

//输出
void PrintS(token t) {
    
	switch (t) {
    
	case lc:printf("/*"); break;
	case lbrc:printf("{"); break;
	case lbrkt:printf("["); break;
	case lpr:printf("("); break;
	case rc:printf("*/"); break;
	case rbrc:printf("}"); break;
	case rbrkt:printf("]"); break;
	case rpr:printf(")"); break;
	default:break;
	}
}