使用栈，实现括号匹配

问题描述

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例1：

输入: "()"
输出: true

示例2：

输入: "()[]{}"
输出: true

示例3：

输入: "([)]"
输出: false

在我们的编辑器中会很智能的提示括号是否匹配出错，使用的技术大致与本文章中的叙述相似，只是实现的代码会不同！

示范代码：

在匹配值有括号的字符串中该方法很管用，当字符串是一个表达式，例如：{3*(9-2)}/[8+2]时就会出错了。因为该代码没有对其他字符进行判断；

public boolean isValid(String s1) {
		Stack<Character> stack = new Stack<Character>();
		for (int i = 0; i < s1.length(); i++) {
			if (s1.charAt(i) == '(') {
				stack.push(')');
			} else if (s1.charAt(i) == '{') {
				stack.push('}');
			} else if (s1.charAt(i) == '[') {
				stack.push(']');
			} else if (stack.isEmpty() || stack.pop() != s1.charAt(i)) {
				return false;
			}
		}
		return stack.isEmpty() ? true : false;
}

示例代码2

以下是我使用自己实现的栈，换了一种思路的方法，该方法可以对表达式中含有括号进行匹配；
但是可读性没有上面的代码好，大家自己取舍

栈代码：

public class ArrayStack<E> {
	private int top = -1;//top指的始终是栈顶元素
	private E[] data;
	public ArrayStack(){
		init(20);
	}
	public ArrayStack(int capacity){
		init(capacity);
	}
	private void init(int capacity){
		data = (E[])new Object[capacity];
	}
	public boolean isEmpty(){
		return getSize()>=0?false:true;
	}
	public int getSize(){
		return top;
	}
	public int getCapacity(){
		return data.length;
	}
	
	public void push(E elem){
		if(getSize()>=data.length){
			throw new IllegalArgumentException("栈已满");
		}
		data[++top] = elem;
	}
	public E pop(){
		if(isEmpty()){
			throw new IllegalArgumentException("栈为空");
		}
		return data[top--];
	}
	public E peek(){
		return data[top];
	}
	public String toString(){
		StringBuilder sb = new StringBuilder();
		for(int i = top-1;i>=1;i--){
			sb.append(data[i]+"->");
		}
		sb.append(data[0]);
		return sb.toString();
	}
}

匹配括号代码：

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class KuoHaoMatch {
	ArrayStack<Character> as = new ArrayStack<>();

	public static void main(String[] args) {
		KuoHaoMatch khm = new KuoHaoMatch();
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一串括号组合：");
		String s = input.next();

		if (test2(s)) {			//此处可以通过更换方法名，对每一个函数进行测试
			System.out.println("匹配成功");
		} else {
			System.out.println("匹配失败");
		}
	}

	public static boolean test1(String s1, KuoHaoMatch khm) {
		if(s1 == null){
			return true;
		}
		int i = 0;
		while (i < s1.length()) {
			char c = s1.charAt(i);
			i++;
			if (c == '(' || c == '[' || c == '{') {
				khm.as.push(c);
			} else {
				if (!khm.as.isEmpty()) {
					if (c == ')') {
						if (khm.as.peek() == '(') {
							khm.as.pop();
						} else {
							return false;
						}
					} else if (c == '}') {
						if (khm.as.peek() == '{') {
							khm.as.pop();
						} else {
							return false;
						}
					} else if (c == ']') {
						if (khm.as.peek() == '[') {
							khm.as.pop();
						} else {
							return false;
						}
					} else {
						continue;
					}
				}
			}

		}
		if (!khm.as.isEmpty()) {
			return false;
		} else {
			return true;
		}

	}

	public static boolean test2(String s1, KuoHaoMatch khm) {
		if(s1 == null){
			return true;
		}
		Map<Object, Object> hm = new HashMap<>();
		hm.put(')', '(');
		hm.put('}', '{');
		hm.put(']', '[');
		int i = 0;
		while (i < s1.length()) {
			char c = s1.charAt(i);
			i++;
			if (c == '(' || c == '[' || c == '{') {
				khm.as.push(c);
			} else {
				if (!khm.as.isEmpty()) {
					if (c == ']' || c == ')' || c == '}') {
						if (khm.as.peek() == hm.get(c)) {
							khm.as.pop();
						} else {
							return false;
						}
					} else {
						continue;
					}
				}
			}
		}
		if (khm.as.getSize() >= 0) {
			return false;
		} else {
			return true;
		}
	}

欢迎大家指出我代码中的漏洞；