算法-括号问题

1.判断括号有效

一般使用栈进行判断

（1）（），{}，[]

使用一个栈

class Solution {
    public boolean isValid(String s) {
        //java中推荐使用Deque替代Stack，Deque堆栈操作方法：push()、pop()、peek()
        Deque<Character> stack=new LinkedList<>();
        char[] c=s.toCharArray();
        for(char ch:c){
            if(ch=='(' || ch=='{'|| ch=='['){
                stack.push(ch);
            }else{
                if(!stack.isEmpty() && charOf(ch)==stack.peek()){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }
    public char charOf(char ch){
        if(ch==')') return '(';
        if(ch=='}') return '{';
        return '[';
    }
}

（2）（）加入*

使用两个栈

class Solution {
    public boolean checkValidString(String s) {
        int n=s.length();
        if(s==null || n==0){
            return true;
        }
        //使用两个栈分别存放(和*的位置下标
        //如果最后starStack的size大于等于leftStack的size并且迭代比较starStack和leftStack的栈顶元素
        //只有starStack大于等于leftStack的栈顶元素，返回true，否则返回false
        Deque<Integer> leftStack=new LinkedList<>();//存储'('的下标
        Deque<Integer> starStack=new LinkedList<>();//存储'*'的下标
        char[] charArr=s.toCharArray();

        for(int i=0;i<charArr.length;i++){
            if(charArr[i]=='('){
                leftStack.push(i);
            }else if(charArr[i]=='*'){
                starStack.push(i);
            }else{
                if(!leftStack.isEmpty()){
                    leftStack.pop();
                }else if(!starStack.isEmpty()){
                    starStack.pop();
                }else{
                    return false;
                }
            }
        }
        if(starStack.size()<leftStack.size()){
            return false;
        }
        while(leftStack.size()>0 && starStack.size()>0){
            if(starStack.peek()<leftStack.peek()){
                return false;
            }
            starStack.pop();
            leftStack.pop();
        }
        return true;
    }
}

2.括号生成

使用回溯

class Solution {
    List<String> res=new LinkedList<>();
    public List<String> generateParenthesis(int n) {
        if(n==0){
            return res;
        }
        StringBuilder sb=new StringBuilder();
        backTrack(n,n,sb);
        return res;
    }
    //向字符串中添加字符'('或者')',左括号剩余个数应该始终小于等于右括号剩余个数
    public void backTrack(int nLeft,int nRight,StringBuilder sb){
        if(nLeft==0 && nRight==0){
            res.add(new String(sb.toString()));
            return;
        }
        if(nLeft<0 || nRight<0){
            return;
        }
        if(nLeft>nRight){
            return;
        }
        sb.append('(');
        backTrack(nLeft-1,nRight,sb);
        sb.deleteCharAt(sb.length()-1);

        sb.append(')');
        backTrack(nLeft,nRight-1,sb);
        sb.deleteCharAt(sb.length()-1);
    }
    
}