一、栈
二、算法
1.括号匹配
Leetcode 20： 有效的括号
题目描述：
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例：
示例 1:
输入: "()"
输出: true
示例 2:
输入: "()[]{}"
输出: true
示例 3:
输入: "(]"
输出: false
示例 4:
输入: "([)]"
输出: false
示例 5:
输入: "{[]}"
输出: true
【思路】用栈保存括号的左半部分，遇到左半部分就入栈；遇到右半部分就查看栈顶元素是否与该括号为一对，如果是，就将栈顶元素出栈，否则，返回错误，表示该串括号无效。
代码如下：
def isValid(s):
stack_ = []
if s == '':
return True
if len(s) == 1:
return False
list_s = list(s)
for i in range(len(list_s)):
if list_s[i] == '(' or list_s[i] == '[' or list_s[i] == '{':
stack_.append(s[i])
else:
print('stack_',stack_)
if len(stack_) > 0:
if stack_[-1] == None:
return False
if list_s[i] == ')' and stack_[-1] != '(':
return False
elif list_s[i] == ']' and stack_[-1] != '[':
return False
elif list_s[i] == '}' and stack_[-1] != '{':
return False
if list_s[i] and stack_ == []:
return False
stack_ = stack_[:-1]
return stack_ == []
res = isValid('[]]')
print(res)
Leetcode 32： 最长有效括号
题目描述：给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。
示例：
示例 1:
输入: "(()"
输出: 2
解释: 最长有效括号子串为 "()"
示例 2:
输入: ")()())"
输出: 4
解释: 最长有效括号子串为 "()()"
思路：基于判断括号有效子集的方法扩展，主要思想是扫描字符串，遇到“（”的时候，将对应的index存储在stack中，遇到“）”的时候，意味着可能遇到了一个有效子字符串，所以需要维护一个maximam变量。 计算maximum的方法是，存一个start变量，是我们认为的有效的子集开始的位置，然后遍历字符串，利用不同的位置减去start得到的值，来维护maximum。
时间复杂度：O（n）
空间复杂度：O（n）
代码如下：
def longestValidParentheses(s):
stack = []
start = 0
maximum = 0
for i in range(len(s)):
if s[i] == '(':
stack.append(i)
else:
if stack == []:
start = i + 1
else:
stack.pop()
if stack != []:#说明是)前面紧跟着(
maximum = max(maximum,i-stack[-1])
else:#说明)前面有不止一个(，就要计算start到当前i的距离
maximum = max(maximum,i-start+1)
return maximum
Leetcode 856： 括号的分数
题目描述：
给定一个平衡括号字符串S，按下述规则计算该字符串的分数：
()得1分。
AB得A + B分，其中A和B是平衡括号字符串。
(A)得2 * A分，其中A是平衡括号字符串。
示例：
示例1：
输入： "()"
输出： 1
示例2：
输入： "(())"
输出： 2
示例3：
输入： "()()"
输出： 2
示例4：
输入： "(()(()))"
输出： 6
提示：S是平衡括号字符串，且只含有(和)。2 <= S.length <= 50
思路1：递归
对给定的字符串，找出与最左边的括号相匹配的右括号的下标index，如果这两个括号正好占据了字符串一左一右的两侧边界，则最后的分数为这两个括号中间部分的子字符串的分数 * 2。否则最后的分数等于下标index将S分成的左右两个平衡括号字符串分数之和。
思路2：栈
括号匹配的题目一般要用到栈，这个题也是。我们用栈保存两样东西：一是左括号(，二是得分。这样我们在遇到)返回的时候，可以直接判断栈里面是左括号还是得分。
如果是左括号(，那么得分是1，放入栈中。
如果是得分，那么我们需要一直向前求和直到找到左括号为止，然后把这个得分×2，放入栈中。
由于题目给的是符合要求的括号匹配对，那么栈里面最后应该只剩下一个元素了，就是最终得分。
思路1代码：
from collections import OrderedDict
class Solution (object):
# 找第一个左括号的右括号对应的右括号的位置
def FindFirstRightkh(self,S):
stack = []
dict_S = OrderedDict()
for idx,s in enumerate(list(S)):
if s == '(':
stack.append(idx)
elif s == ')' and len(stack) >= 1:
dict_S[stack[-1]] = idx
if stack[-1] == 0:
return idx
stack.pop()
# print(dict_S) #{1: 2, 4: 5, 3: 6, 0: 7}
def scoreOfParentheses(self, S):
score = 0
if S == '()':
return 1
elif S =='(())':
return 2
elif S == '()()':
return 2
idx_Rightkh = self.FindFirstRightkh(S)
if idx_Rightkh == len(S) - 1:
score = 2 * self.scoreOfParentheses(S[1:idx_Rightkh])
else:
score = self.scoreOfParentheses(S[:idx_Rightkh+1]) + self.scoreOfParentheses(S[idx_Rightkh+1:])
return score
思路2代码：
class Solution1 (object):
def scoreOfParentheses1(self, S):
"""
:type S: str
:rtype: int
"""
scoreStack = []
for c in S:
if c == '(': #如果是'(',就将-1入栈
scoreStack.append(-1)
else:#右括号
score = 0
while scoreStack[-1] != -1:#如果是得分，就一直加，直到遇到-1，得到内部的括号之和
score += scoreStack.pop()
scoreStack.pop()#弹出不是-1的
if score == 0:
scoreStack.append(1)
else: #得分不为0，说明栈顶不为-1，得2倍分
scoreStack.append(2 * score)
totalScore = 0
while scoreStack != []:
totalScore += scoreStack.pop()
return totalScore
s = Solution()
res = s.scoreOfParentheses(S='((())(()))')
print(res)
Leetcode 921： 使括号有效的最少添加
题目描述：给定一个由'('和')'括号组成的字符串S，我们需要添加最少的括号（ '('或是')'，可以在任何位置），以使得到的括号字符串有效
说明：从形式上讲，只有满足下面几点之一，括号字符串才是有效的：
它是一个空字符串，或者它可以被写成AB（A与B连接）, 其中A和B都是有效字符串，或者它可以被写作 (A)，其中A是有效字符串。
给定一个括号字符串，返回为使结果字符串有效而必须添加的最少括号数。
示例1：
输入："())"
输出：1
示例2：
输入："((("
输出：3
示例3：
输入："()"
输出：0
示例4：
输入："()))(("
输出：4
提示：
S.length <= 1000
S只包含'('和')'字符。
思路：
代码如下：
class Solution:
def minAddToMakeValid(self, S):
"""
:type S: str
:rtype: int
"""
if S == '':
return 0
stack = []
right_kh_count = 0
left_kh_count = 0
for s in S:
if s == '(':
stack.append(s)
elif s == ')' and stack != []:
stack.pop()
else:
left_kh_count += 1
if stack != []:
right_kh_count = len(stack)
return left_kh_count + right_kh_count
def minAddToMakeValid_leetcode(self, S):
if S == '':
return 0
stack = []
for s in S:
if s == ')' and len(stack) >0 and stack[-1] == '(':
stack.pop()
else:
stack.append (s)
return len(stack)
s = Solution()
num = s.minAddToMakeValid_leetcode(S='())')
print(num)
2.下一个更大元素
Leetcode 496：下一个更大元素I
题目描述：给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。
说明：nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。
示例：
示例 1:
输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
示例 2:
输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
对于num1中的数字2，第二个数组中的下一个较大数字是3。
对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。
注意:
nums1和nums2中所有元素是唯一的。
nums1和nums2 的数组大小都不超过1000。