如何检查字符串中左括号和右括号的顺序？

Question

需要查找左括号和右括号，如果违反了右括号的顺序，则返回false。

但是，如果不还原右数组以与左数组进行比较，则我不会在此处{[(3+1)+2]+}加上方括号。如果像现在这样反转，那么我无法在此处检查[1+1]+(2*2)-{3/3}

function brackets(expression){
    let leftArr=[];
    let rightArr = [];
    for(let i=0; i<expression.length; i++){
    		if(expression[i] === '(' || expression[i] === '[' || expression[i] === "{"){
        	leftArr.push(expression[i]);
        }
        
        
        if(expression[i] === ')'){
      
        		rightArr.push("(");
        }else if(expression[i] === '}'){
        
        		rightArr.push("{");
        } else if(expression[i] === ']'){
        
        		rightArr.push("[");
        }
   }
		
   rightArr.reverse();
    
    if(leftArr.length<rightArr.length || leftArr.length>rightArr.length){
    return false;
    }
    
    for(let k=0; k<leftArr.length; k++) {
    		if(leftArr[k] != rightArr[k]){
        		return false;
        }
    }

    return true;
}



console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false

Answer 1

在最短的时间内加上注释，可能会使您感到困惑<3

function check(expr){
    let holder = []
    let openBrackets = ['(','{','[']
    let closedBrackets = [')','}',']']
    for(let letter of expr){ // loop trought all letters of expr
        if(openBrackets.includes(letter)){ // if its oppening bracket
            holder.push(letter)
        }else if(closedBrackets.includes(letter)){ // if its closing
            let openPair = openBrackets[closedBrackets.indexOf(letter)] // find his pair
            if(holder[holder.length - 1] === openPair){ // check if that pair is last element in array
                holder.splice(-1,1) //if so, remove it
            }else{ // if its not
                holder.push(letter)
                break // exit loop
            }
        }
    }
    return (holder.length === 0) // return true if length is 0, otherwise false
}
check('[[{asd}]]') /// true

Answer 2

现在，您将每个单独的开括号放入一个数组中，然后将每个关闭的方括号放入一个开括号中，然后进行比较。那有点浪费。

相反，您可以维护堆栈。将打开的标签推到堆栈上，如果找到右括号，则从堆栈中弹出

• 如果弹出时没有匹配项或堆栈上没有任何内容，则以失败终止
• 如果堆栈大小为零，则表示成功

function brackets(expression) {
  let stack = [];
  let current;
  const matchLookup = {
        "(": ")", 
        "[": "]", 
        "{": "}", 
      };
                    
  for (let i = 0; i < expression.length; i++) {
    current = expression[i]; //easier than writing it over and over
    
    if (current === '(' || current === '[' || current === "{") {
      stack.push(current);
      
    } else if (current === ')' || current === ']' || current === "}") {
      const lastBracket = stack.pop();
      
      if (matchLookup[lastBracket] !== current) { //if the stack is empty, .pop() returns undefined, so this expression is still correct
      
        return false; //terminate immediately - no need to continue scanning the string
      }
    }
  }
  
  return stack.length === 0; //any elements mean brackets left open
}

console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false

我已经使用一个对象来查找值，但是它不必是一个。一种替代方法是使用两个必须保持同步的数组

opening = ["(", "[", "{"]
closing = [")", "]", "}"]

另一方面，如果有的话，可以将if的支票缩短为if (open.includes(current))和if (closing.includes(current))。

Answer 3

您可以使用函数String.prototype.replace来收集方括号，并使用一种堆栈来比较每个字符。堆栈对于了解最后插入的括号是有用的。

let check = (e) => {
  let brackets = [],
      stack = [],
      map = {'}': '{', ']': '[', ')': '('};

  e.replace(/[\[\]\{\}\(\)]/g, (m) => m && brackets.push(m));

  for (let i = 0, {length} = brackets; i < length; i++) {
    if (['}', ']', ')'].includes(brackets[i])) {
      if (stack.pop() !== map[brackets[i]]) return false;
    } else stack.push(brackets[i]);
  }

  return !stack.length;
};
    
    
console.log(check('(3+{1-1)}')); // false
console.log(check('{[(3+1)+2]+}')); //true
console.log(check('[1+1]+(2*2)-{3/3}')); //true
console.log(check('(({[(((1)-2)+3)-3]/3}-3)')); //false

Answer 4

您可以将带开关语句的堆栈与单个for循环一起使用，以提高时间和空间的复杂性

function checkParantesis(str) {
    const stack = [];
    for (let s of str) {
       if (s == '(' || s == '[' || s == '{') {
          stack.push(s);
          continue; 
       }

       if (stack.length === 0) {
           return false
       }

       switch (s) {
           case ')':
                stack.pop();
                if (s == '{' || s == '[') {
                  return false  
                }
                break;
           case '}':
                stack.pop();
                if (s == '(' || s == '[') {
                  return false  
                }
                break;
           case ']':
                stack.pop();
                if (s == '{' || s == '(') {
                  return false  
                }
                break;
       }
    }
    return stack.length ? false : true
}

const output = checkParantesis('{{}}'));
console.log(output)

Answer 5

我希望这能解决您的问题...

function brackets(expression) {
    let leftArr=[];
    
    for(let i=0; i<expression.length; i++) {
        if(expression[i] === '(' || expression[i] === '[' || expression[i] === "{") {
            leftArr.push(expression[i]);
        } 
        
        let leftArrLength = leftArr.length;
        
        if(expression[i] === ')' && leftArr[leftArrLength - 1] === '('){
            leftArr.pop();
        }else if(expression[i] === '}' && leftArr[leftArrLength - 1] === '{') {
            leftArr.pop();
        } else if(expression[i] === ']' && leftArr[leftArrLength - 1] === '[') {  
            leftArr.pop();
        }
        else if(expression[i] === ')' || expression[i] === '}' || expression[i] === ']'){
         return false;
        }
    }
	
    return leftArr.length === 0;
}



console.log(brackets('(3+{1-1)}')); // false
console.log(brackets('{[(3+1)+2]+}')); //true
console.log(brackets('[1+1]+(2*2)-{3/3}')); //true
console.log(brackets('(({[(((1)-2)+3)-3]/3}-3)')); //false
console.log(brackets('(((([[[[{{{3}}}]]]]))))')); //false