使用 JavaScript 的有效括号 leetcode 问题答案

【问题标题】：Valid Parentheses leetcode problem using JavaScript使用 JavaScript 的有效括号 leetcode 问题
【发布时间】：2023-01-28 08:13:47
【问题描述】：

我正在尝试使用 JavaScript 从 leetcode 中找出有效的括号问题，但我无法找出解决此问题的计划。

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.
Every close bracket has a corresponding open bracket of the same type.


Example 1:

Input: s = "()"
Output: true

Example 2:

Input: s = "()[]{}"
Output: true

Example 3:

Input: s = "(]"
Output: false

我目前的思考过程是这样的：

将字符串拆分为数组（示例：“{}” --> [“{”，“}”，“[”，“]”，“（”，“）”]
遍历数组
使用每个字符的索引来比较...？
在此之后不确定...
请帮忙。

【问题讨论】：

要解决此问题，请使用堆栈。这会很容易。
如果您想找到解决方案，我建议您参考讨论部分。

标签： javascript

【解决方案1】：

这是一个简单的堆栈实现：

const BRACKETS = [['(', ')'], ['[', ']'], ['{', '}']];
const OPEN = BRACKETS.reduce((a, [o, c]) => ({...a, [o]: c}), {});
const CLOSE = BRACKETS.reduce((a, [o, c]) => ({...a, [c]: o}), {});

const isBalanced = (s) => {
  const stack = [];
  
  for (const c of [...s]) {
    if (c in OPEN) stack.push(c);
    if (c in CLOSE && stack.pop() !== CLOSE[c]) return false;
  }
  
  return !stack.length;
};

console.log(isBalanced('{{[()]()}}'));
console.log(isBalanced('{[)}'));

我首先为左括号和右括号创建两个查找对象。然后这只是循环字符的问题，并且：

如果是左括号，将其推入堆栈；
如果是右括号，将最后一个值弹出堆栈并检查它是否与右括号匹配；
一切处理完毕后，检查栈是否为空。

【讨论】：

感谢您的帮助，但是，作为初学者很难理解您的代码......有没有更简单的方法来解决这个问题？

【解决方案2】：

const OPENING_BRACKETS = ['(', '[', '{']
const CLOSING_BRACKETS = [')', ']', '}']

const hasBalancedBrackets = text => !countUnmatchedBrackets(text)

function countUnmatchedBrackets(text) {
  return [...text].filter(isBracket).reduce((stack, bracket) =>
    isOpen(bracket) || !isMatch(stack.at(-1), bracket)
      ? /* push */ stack.concat(bracket)
      : /* pop  */ stack.slice(0, stack.length - 1), []).length
}

function isMatch(lastBracket, bracket) {
  return OPENING_BRACKETS.some((openBracket, i) =>
    lastBracket === openBracket &&
    bracket === CLOSING_BRACKETS[i])
}

function isBracket(char) { return isOpen(char) || CLOSING_BRACKETS.includes(char) }
function isOpen(bracket) { return OPENING_BRACKETS.includes(bracket) }

[
  [false, '[){'],
  [true, 'a()a'],
  [true, '{{[([a]a)a]a}}'],
  [false, 'aa{a}a[aa(a](({[{a[[[()(([[a']
].forEach(([expected, input]) =>
  console.assert(expected === hasBalancedBrackets(input), input))

【讨论】：

【解决方案3】：

Javascript 中的有效括号 （在很多采访中被问到。简单且被接受的解决方案。）

这里使用的方法是字符串迭代和 charAt 和替换方法。

var isValid = function(s) {
    let par ={'(' :')','{': '}', '[':']'};
    for(let i=0;i<s.length;++i) {
        if(s.charAt(i+1) && s.charAt(i+1)== par[s.charAt(i)]){
                s = s.replace(s.charAt(i)+s.charAt(i+1),'');
                i=i-2;
        }
    }
    if(s.length){
        console.log(false)
        return false;
    } else {
        console.log(true)
        return true;
    }
};
console.log(isValid("()[]{}"))

【讨论】：

【解决方案4】：

const isValid = (s) => {
  let stack = [];
  const map = new Map([
    ['(', ')'],
    ['{', '}'],
    ['[', ']'],
  ]);

  for (let i = 0; i < s.length; i++) {
    if (s[i] == '(' || s[i] == '{' || s[i] == '[') {
      stack.push(s[i]);
    } else {
      const last = stack.pop();
      if (s[i] !== map.get(last)) {
        return false;
      }
    }
  }

  return stack.length === 0;
};

【讨论】：