LC20. 有效的括号

我的思路：

将字符串转为数组，取到每个括号的个数，以及最大的索引值。

找到所有false的可能情况，将左右括号分类，进行两个判断：

1）若左括号和右括号不相等，则false

2）若最右边的左括号大于最右边的右括号，则返回false

3）剩余的返回true

//leetcode 20. 有效的括号
/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function (s) {
    //思路：分类，排除法
    //对于小括号，如果左括号个数不等于右括号，false
    //如果相等，则判断索引值大小，只有右括号索引值最大的情况下为false
    //最后对于中括号，大括号采取相同的办法
    var LeftSmallNum = 0;
    var RightSmallNum = 0;
    var LeftSmallIndex = 0;
    var RightSmallIndex = 0;
    var LeftMediumNum = 0;
    var RightMediumNum = 0;
    var LeftMediumIndex = 0;
    var RightMediumIndex = 0;
    var LeftLargeNum = 0;
    var RightLargeNum = 0;
    var LeftLargeIndex = 0;
    var RightLargeIndex = 0;
    var arr = [];
    //step1：字符串转为数组
    s.split('').forEach(e => {
        arr.push(e)
    })
    //step2：循环数组
    arr.forEach(function (item, index, array) {
        // item数组中的当前项, index当前项的索引, array原始数组；
        if (item == "(") {
            LeftSmallNum++;
            LeftSmallIndex = index;
        }
        if (item == ")") {
            RightSmallNum++;
            RightSmallIndex = index;
        }
        if (item == "[") {
            LeftMediumNum++;
            LeftMediumIndex = index;
        }
        if (item == "]") {
            RightMediumNum++;
            RightMediumIndex = index;
        } if (item == "{") {
            LeftLargeNum++;
            LeftLargeIndex = index;
        }
        if (item == "}") {
            RightLargeNum++;
            RightLargeIndex = index;
        }

    })


    if (LeftSmallNum !== RightSmallNum) {
        return false
    } else if (LeftMediumNum !== RightMediumNum) {
        return false
    } else if (LeftLargeNum !== RightLargeNum) {
        return false
    } else if (LeftSmallIndex > RightSmallIndex) {
        return false;
    } else if (LeftMediumIndex > RightMediumIndex) {
        return false;
    } else if (LeftLargeIndex > RightLargeIndex) {
        return false;
    } else {
        return true
    }

};

isValid("((()))[]")

结果很接近，但是不够全面。

这是由于以上思维将大小中括号分开判断，他们组合起来也会产生false，如下：

 思维肯定出问题了，所以找到大佬答案：

先进行判断字符串长度是否为偶数 如果不是则直接 returan false;
是偶数，因为每个括号都是两个字符组成，所以遍历长度为 let length = len / 2;
每次遍历找到对应的括号将它替换成""。

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
	let len =s.length;
	if(len % 2 !==0 ){
		return false;
	}
 	let length = len / 2;
		for (let i = 0; i < length; i++) {
			s = s.replace("()", "");
			s = s.replace("{}", "");
			s = s.replace("[]", "");
		}

	return s.length === 0;
};

作者：mr-wang-y-p
链接：https://leetcode.cn/problems/valid-parentheses/solution/by-mr-wang-y-p-uz6a/
来源：力扣（LeetCode）

答案2:

根据题意，我们可以推断出以下要点：

有效括号字符串的长度，一定是偶数！
右括号前面，必须是相对应的左括号，才能抵消！
右括号前面，不是对应的左括号，那么该字符串，一定不是有效的括号！

// 解法一
let isValid = function(s) {
    let stack = [], length = s.length;
    if(length % 2) return false;
    for(let item of s){
        switch(item){
            case "{":
            case "[":
            case "(":
                stack.push(item);
                break;
            case "}":
                if(stack.pop() !== "{") return false;
                break;
            case "]":
                if(stack.pop() !== "[") return false;
                break;
            case ")":
                if(stack.pop() !== "(") return false;
                break;
        }
    }
    return !stack.length;
};

// 解法二
var isValid = function(s) {
    s = s.split('');
    let sl = s.length;
    if (sl % 2) return false;
    let map = new Map([[')', '('], [']', '['], ['}', '{']]);
    let stack = [];
    for(let i of s){
        if (map.get(i)) {
            if (stack[stack.length - 1] !== map.get(i)) return false;
            else stack.pop();
        } else {
            stack.push(i);
        }
    }
    return !stack.length;
};

作者：demigodliu
链接：https://leetcode.cn/problems/valid-parentheses/solution/guan-fang-tui-jian-ti-jie-you-xiao-de-gu-zyzg/
来源：力扣（LeetCode）