括号匹配问题

No.1：问题描述

有一段字符串序列，其中只含有' [ '，' ] '，' ( '，‘ ) ’四种括号，现在需要判断一下这个字符串序列中的括号是否配对。

No.2：程序输入

第一行输入数n，表示有n条测试字符串，n > 0。

接下来输入每组非空测试字符串，字符串长度<10000。

No.3：程序输出

如果字符串中的括号配对则输出Yes，如果不配对则输出No。

No.4：问题解决

检查序列中的括号是否配对的策略，如下：
1. 遍历序列中的每一个括号
2. 若序列中第一个括号为右括号，则序列不配对，程序结束
3. 若扫描到的括号为左括号，则让该括号入栈
4. 若扫描到的括号为右括号，若此时栈顶的左括号与其配对，则让栈顶元素出栈，扫描下一个元素
5. 若扫描到的括号为右括号，若此时栈顶的左括号与其不配对，则序列中左括号多于右括号，序列不配对，程序结束
6. 若扫描到的括号为右括号，若此时栈已空，则序列中左括号少于右括号，序列不配对，程序结束
7. 在扫描结束后，如果栈已空，则序列配对

No.5：栈的定义

定义一个栈，实现了入栈、出栈、获取栈顶元素、判断栈空、打印栈中元素等基本功能。

class Stack {
	
	/**
	 * 栈的初始化
	 * @param size 栈大小
	 */
	public Stack(int size) {
		this.data = new char[size];
		p = -1;
	}
	
	/**
	 * 判断栈是否为空
	 * @return 若空返回true，否则，返回false
	 */
	public boolean isEmpty() {
		if(p < 0) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 获取栈顶元素
	 * @return 栈顶元素值
	 */
	public char getTop() {
		if(p > -1) {
			return data[p];
		} else {
			return '0';
		}
	}
	
	/**
	 * 出栈
	 */
	public void pop() {
		if(p >= 0) {
			--p;
		} else {
			System.err.println("栈空!");
		}
	}
	
	/**
	 * 入栈
	 * @param c 需要入栈的元素
	 */
	public void push(char c) {
		if(p < data.length - 1) {
			++p;
			data[p] = c;
		} else {
			System.err.println("栈满!");
		}
	}
	
	/**
	 * 打印栈中的元素
	 */
	public void printStack() {
		if(!isEmpty()) {
			for(int i=0; i<=p; ++i) {
				System.out.print(data[i] + " ");
			}
			System.out.println();
		} else {
			System.err.println("栈空!");
		}
	}
	
	private char[] data;//栈的结构
	private int p;//栈顶指针
}

No.6：程序入口

定义Java主函数，按照步骤4所阐述的策略对括号字符串进行检查。

public static void main(String[] args) {
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	try {
		int group = Integer.parseInt(in.readLine());
		boolean flag;
		char[] c;
		Stack s;
		while(group > 0) {
			flag = true;
			c = in.readLine().trim().toCharArray();
			s = new Stack(c.length);
			if(c[0] == '[' || c[0] == '(') {
				s.push(c[0]);
				for(int i=1; i<c.length; ++i) {
					
					//当前字符为左括号，则入栈
					if(c[i] == '[' || c[i] == '(') {
						s.push(c[i]);
					}
					
					//当前字符串为右括号，且栈顶元素为左括号，则出栈，进入下次循环
					if((c[i] == ']' && s.getTop() == '[') || (c[i] == ')' && s.getTop() == '(')) {
						s.pop();
						continue;
					}
					
					//左括号多于右括号
					if((c[i] == ']' && s.getTop() == '(') || (c[i] == ')' && s.getTop() == '[')) {
						flag = false;
						break;
					}
					
					//右括号多于左括号
					if(c[i] == ']' || c[i] == ')') {
						if(s.isEmpty()) {
							flag = false;
							break;
						}
					}
				}
			} else {
				flag = false;
			}
			
			//遍历结束栈不空，则括号不配对
			if(!s.isEmpty()) {
				flag = false;
			}
			
			if(flag) {
				System.out.println("Yes");
			} else {
				System.out.println("No");
			}
			--group;
		}
		in.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

No.7：测试效果

测试5组数据效果如下：