Javascript 算法：优化'；平衡支架'；

有人向我提出了以下问题……

给定字符串“（{[}]）”中的N个不同的开括号和闭括号，检查该字符串是否有匹配的大括号。如果大括号匹配，则返回true，否则返回false

这是我想到的答案…

函数braceql（大括号）{
var-leftpar=0；
var-rightpar=0；
var-leftbrace=0；
var rightbrace=0；
var-leftcurl=0；
var-rightcurl=0；
对于（变量索引=0；索引

这确实是一段内容丰富的代码，但它确实有效。我看到了关于其他人如何攻击此问题的不同意见，但我想知道是否有更好/更干净的方法来解决此算法而不影响大O？

---

我非常愿意接受建议和其他方式来看待这个问题。

首先，你的解决方案似乎不包括以下情况：（][或（{）}（我不确定你是否被要求这样做，但我知道这个玩具问题要求这样做）

这是我一年多前提出的玩具问题的解决方案，但它似乎更快（如果不匹配，它会更早停止，ifs和ELSE更少），重复的代码也更少，但我不确定是否更干净，因为从新手的角度来看，ifs和ELSE更容易理解

var braceeql = function(braces){
  var stack = {};
  var size = 0;
  var beginners = ['(', '[', '{'];
  var enders = [')', ']', '}'];
  for(var i = 0; i < braces.length; i++){
    if( beginners.indexOf(braces[i]) !== -1 ){
      stack[size] = braces[i];
      size++;
    } else if( enders.indexOf(braces[i]) !== -1 ){
      if(size === 0) { return false; }
      var index = enders.indexOf(braces[i]);
      if(stack[size-1] === beginners[index] ){
        size --;
      } else {
        return false;
      }
    }
  }

  return size === 0;
};

var braceql=函数（大括号）{
var stack={}；
变量大小=0；
var初学者=['（'，['，{']；
变量enders=['）'、']'、'}']；
对于（var i=0；i

这是我对这个问题的看法：

const isBalance = str => {
  const result = !str.split('').reduce((accum, current) => {
    if (accum < 0) return accum
    else {
      if (current === '(') return accum+= 1
      if (current === ')') return accum-= 1
      if (current === '[') return accum+= 2
      if (current === ']') return accum-= 2
      if (current === '{') return accum+= 3
      if (current === '}') return accum-= 3    
    }

  }, 0)

  return result
}

const isBalance=str=>{
常量结果=！str.split（“”）.reduce（（累计，当前）=>{
如果（累计<0）返回累计
否则{
如果（当前==='（'）返回accum+=1
如果（当前=='））返回累计-=1
如果（当前=='['）返回accum+=2
如果（当前==']'）返回累计-=2
如果（当前=='{'）返回累计+=3
如果（当前=='}'）返回累计-=3
}
}, 0)
返回结果
}

此解决方案将为您提供O（n）。 可以改进此解决方案的一件事是，如果我们达到

acum<0

（这意味着存在一个不匹配的闭合大括号），您可以立即停止迭代

---

另外，阅读代码要容易得多，这可能是一种延伸，但为什么不使用定义良好的堆栈呢？这是一种很好的做法

//stack
class STACK 
{
  //initialize
  constructor()
  {
    this.arr = [];
  }
  //add to stack
  add(data)
  {
    this.arr.push(data);
  }
  //remote from stack
  remove()
  {
    return this.arr.pop();
  }
  //print the stack
  print()
  {
    console.log('-----');
    for(let i = this.arr.length-1; i >=0; i--)
      console.log('|',this.arr[i],'|');
    console.log('-----');
  }
  //peek last element
  peek()
  {
    return this.arr[this.arr.length-1];
  }
  //check if empty
  empty()
  {
    if(this.arr.length===0)
      return true;
    else
      return false;
  }
}

//Use stack to check for balanced paranthesis
const balanceParantheses = (str)=>{
  obj = new STACK();
  for(let char of str)
  {
    if(char==='[' || char==='{' || char ==='(')
      obj.add(char);
    else {
      switch(char)
      {
        case(']'):
          if(obj.empty())
            return false;
          else if(obj.peek()!=='[') {
            return false
          } else obj.remove();
          break;
        case(')'):
          if(obj.empty())
            return false;
          else if(obj.peek()!=='(') {
            return false
          } else obj.remove();
          break;
        case('}'):
          if(obj.empty())
            return false;
          else if(obj.peek()!=='{') {
            return false
          } else obj.remove();
          break;
      }
    }
  }
  return true;
}

console.log(balanceParantheses("[()]{}{[()()]()}"));

使用堆栈 以下解决方案的时间复杂度为O（n）

使用一个计数器变量（来源：解决方案#3，第496页）：

let openers={
卷曲：“{”，
正方形：“[”，
帕伦：'（'
};
让闭门器={
卷曲：'}'，
正方形：']'，
帕伦：“）”
};
功能平衡（str）{
设计数器=0；
for（str的let char）{
if（char==openers.curly | | char===openers.square | | char==openers.paren）
计数器++；
if（char===closers.curly | | char===closers.square | | char===closers.paren）
计数器--；
如果（计数器<0）
返回false；
}
返回true；
}
console.log（isBalanced（“[]”）；
log（isBalanced（“][[]”）；
console.log（isBalanced（“[[[[[[[[[[[[][]]][[[[][]]]]]]]”）；
console.log（isBalanced（“][”）；
log（isBalanced（“[[]][]]”）；
console.log（isBalanced（“[][[]]][[[]]]”）；
log（isBalanced（“[[]][[]]”）；
console.log（isBalanced（“[[]]”）；
console.log（isBalanced（“]][][[]][[]”）；
log（isBalanced（“[]”）；
console.log（isBalanced（“][]”）；
log（isBalanced（“[[]][]][”）；
log（isBalanced（“”）；

这是我通过堆栈结构的解决方案

const input = '{a[b{c(d)e}f]g}';

function isBalanced(str) {
  let stack = [];
  let closeMap = new Map([
    [']', '['], 
    ['}', '{'], 
    [')', '(']
  ]);
  let openSet = new Set(closeMap.values());

  for (let ch of str) {
    if(closeMap.has(ch) && 
      (!stack.length || stack.pop() != closeMap.get(ch)))
        return false;            
    else if(openSet.has(ch)) 
      stack.push(ch);
    else continue;
  }

  return (!stack.length)
};

console.log('result is: ' + isBalanced(input));

---

只使用一个变量

brace

、

curl

和

par

，然后递增-递减。最后只需检查所有变量是否都是

=

到

0

。“匹配的大括号”的定义是什么？对我来说，

[（）]

是可以的，

[（]）

不是。您的代码检查后者；对于前者，您需要一个堆栈。如果您只是在寻找改进您的工作代码的方法，那么您可能需要堆栈。@jfriend00:您缺少一个

x

。但是，当前代码不正确（如果

[（]）

无效），因此可能会在CR@Zeta上偏离主题-OP说代码是有效的，所以这就是我要说的。最好的问题有一些描述以及它们粘贴的任何代码。我认为这个问题特别值得解释。这似乎没有注意到涉及到哪个大括号，例如，如果你更改了f

“[}”

的第一个示例将返回

true

，这似乎不正确。这将返回

的
true
（（]”

；仅为特定大括号类型添加值是不够的——这不允许任何上下文，例如哪个大括号。

function isBalanced(str) {
  const map = {
    '(': ')',
    '[': ']',
    '{': '}',
  };
  const closing = Object.values(map);
  const stack = [];
        
  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (closing.includes(char) && char !== map[stack.pop()]) {
      return false;
    }
  }
  return !stack.length;
}

const input = '{a[b{c(d)e}f]g}';

function isBalanced(str) {
  let stack = [];
  let closeMap = new Map([
    [']', '['], 
    ['}', '{'], 
    [')', '(']
  ]);
  let openSet = new Set(closeMap.values());

  for (let ch of str) {
    if(closeMap.has(ch) && 
      (!stack.length || stack.pop() != closeMap.get(ch)))
        return false;            
    else if(openSet.has(ch)) 
      stack.push(ch);
    else continue;
  }

  return (!stack.length)
};

console.log('result is: ' + isBalanced(input));

function isBalanced(str = "") {
    if (typeof str !== "string" || str.trim().length === 0) {
        return false;
    }
    str = str.replace(/[^{}()\[\]]/g, "");
    if (typeof str !== "string" || str.trim().length === 0) {
        return false;
    }
    while (str.length > 0) {
        let perviousLenght = str.length;
        str = str.replace(/\(\)/g, "");
        str = str.replace(/{}/g, "");
        str = str.replace(/["'\[]]/g, "");
        if (str.length === perviousLenght) {
            return false;
        }
    }
    return true;
}
console.log("Good Values ==>");
console.log(isBalanced("[()]"));
console.log(isBalanced("(function(){return [new Bears()]}());"));
console.log(isBalanced("var a = function(){return 'b';}"));
console.log(isBalanced("//Complex object;\n a = [{a:1,b:2,c:[ new Car( 1, 'black' ) ]}]"));
console.log("Bad Values ==>");
console.log(isBalanced("{"));
console.log(isBalanced("{]"));
console.log(isBalanced("{}("));
console.log(isBalanced("({)()()[][][}]"));
console.log(isBalanced("(function(){return [new Bears()}())];"));
console.log(isBalanced("var a = [function(){return 'b';]}"));
console.log(isBalanced("/*Comment: a = [} is bad */var a = function({)return 'b';}"));
console.log(isBalanced("/*[[[ */ function(){return {b:(function(x){ return x+1; })'c')}} /*_)(([}*/"));
console.log(isBalanced("//Complex object;\n a = [{a:1,b:2,c:[ new Car( 1, 'black' ) ]]"));