用不同的思路实现括号匹配（java）

---

给定一个只包括 '('，')' 的字符串，判断字符串是否有效。 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。

---

以上就是题目要求

---

利用替换的思想

()()()()()()()(())

例如需要判断例子中的括号是否有效，用替换的思想具体就是

• 将字符串中所有的（）替换为"";
• 这样一轮下来之后成对的（）就会消失
• 如例子中就会只剩下
  
• 然后进行第二轮的时候就会又替换掉
• 这样所有的（）都会消失掉
• 最后判断字符串的长度是不是0
• 如果是0则表明这串字符中的括号有效
• 那如果不满足条件怎么办

()((()((()))))

• 首先红框标注的部分就会消失（被""替换）
• 现在就剩下(((())))
• 一轮又一轮之后就剩下），
• 这里的判断条件就是新的字符串不为0
• 并且新的长度要比旧的长度小

【具体代码】

public class Test2_2 {
    public static void main(String[] args) {
        System.out.println(isEffective("))))))"));
    }

    public  static boolean isEffective(String str){
        int oldLength = str.length();
        if(oldLength % 2 == 0){
            return false;
        }
        String newStr = str.replace("()","");
        int newLength = str.length();
        while (newLength != oldLength && newLength != 0){
            newLength = oldLength;
            newStr = newStr.replace("()","");
            newLength = newStr.length();
        }
        return newLength == 0;
    }
}

利用栈的思想

• 遇见左括号的时候入栈
• 遇见右括号的时候和栈顶的元素进行比较
• 如果相同则栈中的元素出栈
• 如果不相同则返回错误

import java.util.Scanner;

/**
 * 利用栈进行操作
 */
public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println(judge(str));
    }

    /**
     * 定义一个方法来判断是否括号匹配
     * @param str
     * @return
     */
    public static boolean judge(String str){
        Astack st = new Astack(str.length()/2);
        int i = 0;
        char e;
        boolean flag = false;
        while(i < str.length()){
            e = str.charAt(i);
            if(e=='('){
                st.push(e);
            }
            else {
                if(e == ')'){
                    if(st.isEmpty()){
                        flag = false;
                        break;
                    }
                    if(st.peek() != '('){
                        flag = false;
                        break;
                    }
                    st.pop();
                }
            }
            if(st.isEmpty()){
                flag = true;
            }
            i++;
        }
        return flag;
    }

    /**
     * 用数组模拟一个栈的类
     */
    public static class Astack{
        private int top = -1;
        private int maxsize;
        private char []stack;

        /**
         * 用数组定义一个栈，大小为maxsize;
         * @param maxsize
         */
        public Astack(int maxsize){
            this.maxsize = maxsize;
            stack = new char[maxsize];
        }
        /**
         * 判断栈满
         */
        public boolean isFull(){
            return top == maxsize - 1;
        }
        /**
         * 判断栈空
         */
        public boolean isEmpty(){
            return top == -1;
        }
        /**
         * 入栈
         */
        public void push(char s){
            if(!isFull()){
                top++;
                stack[top] = s;
            }
        }
        /**
         * 出栈
         */
        public char pop(){
            if(isEmpty()){
                throw new RuntimeException("栈满");
            }
            char data = stack[top];
            top -- ;
            return data;
        }
        public char peek(){
            if(isEmpty()){
                throw new RuntimeException();
            }
            return stack[top];
        }
    }
}

【注意】可以用数组模拟一个栈（虽然java中有栈），模拟站的进栈，出栈，取栈顶，判断栈是不是为空，判断栈满等等

栈的简化版

明显可以看出上面的代码比较麻烦，那么可以用栈的思想而不用栈来实现这个题的代码

• 先定义一个left
• 从左向右遍历数组
• 如果出现(则left++，出现）则left- -
• 最后看left是不是0

【代码实现】

public class test4 {
    public static void main(String[] args) {
        System.out.println(isEffective("()"));
    }
    public static boolean isEffective(String str){
        int left = 0;
        for (int i = 0; i < str.length(); i++) {
            char e = str.charAt(i);
            if(e == '('){
                left ++;
            }
            else {
                if(left == 0){
                    return false;
                }
                left --;
            }
        }
        return left == 0;
    }
}

---