leetcode---栈

单个栈计算

20. 有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

71. 简化路径
给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，’//’）都被视为单个斜杠 ‘/’ 。 对于此问题，任何其他格式的点（例如，’…’）均被视为文件/目录名称。
请注意，返回的 规范路径 必须遵循下述格式：
始终以斜杠 ‘/’ 开头。
两个目录名之间必须只有一个斜杠 ‘/’ 。
最后一个目录名（如果存在）不能 以 ‘/’ 结尾。
此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 ‘.’ 或 ‘…’）。

150. 逆波兰表达式求值
根据 逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

224. 基本计算器
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。 只有加减

227. 基本计算器 II
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。，有加减乘除
整数除法仅保留整数部分。

388. 文件的最长绝对路径
假设文件系统如下图所示：

394. 字符串解码
给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

496. 下一个更大元素 I
给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。
请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。
nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

503. 下一个更大元素 II
给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

682. 棒球比赛
你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。
比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：
整数 x - 表示本回合新获得分数 x
“+” - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
“D” - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
“C” - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。
请你返回记录中所有得分的总和。

726. 原子的数量
给你一个字符串化学式 formula ，返回 每种原子的数量 。
原子总是以一个大写字母开始，接着跟随 0 个或任意个小写字母，表示原子的名字。
如果数量大于 1，原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。
例如，“H2O” 和 “H2O2” 是可行的，但 “H1O2” 这个表达是不可行的。
两个化学式连在一起可以构成新的化学式。
例如 “H2O2He3Mg4” 也是化学式。
由括号括起的化学式并佐以数字（可选择性添加）也是化学式。
例如 “(H2O2)” 和 “(H2O2)3” 是化学式。
返回所有原子的数量，格式为：第一个（按字典序）原子的名字，跟着它的数量（如果数量大于 1），然后是第二个原子的名字（按字典序），跟着它的数量（如果数量大于 1），以此类推。

735. 行星碰撞
给定一个整数数组 asteroids，表示在同一行的行星。
对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。
找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。

736. Lisp 语法解析
给定一个类似 Lisp 语句的表达式 expression，求出其计算结果。
表达式语法如下所示:
表达式可以为整数，let 语法，add 语法，mult 语法，或赋值的变量。表达式的结果总是一个整数。
(整数可以是正整数、负整数、0)
let 语法表示为 (let v1 e1 v2 e2 … vn en expr), 其中 let语法总是以字符串 "let"来表示，接下来会跟随一个或多个交替变量或表达式，也就是说，第一个变量 v1被分配为表达式 e1 的值，第二个变量 v2 被分配为表达式 e2 的值，以此类推；最终 let 语法的值为 expr表达式的值。
add 语法表示为 (add e1 e2)，其中 add 语法总是以字符串 "add"来表示，该语法总是有两个表达式e1、e2, 该语法的最终结果是 e1 表达式的值与 e2 表达式的值之和。
mult 语法表示为 (mult e1 e2) ，其中 mult 语法总是以字符串"mult"表示， 该语法总是有两个表达式 e1、e2，该语法的最终结果是 e1 表达式的值与 e2 表达式的值之积。
在该题目中，变量的命名以小写字符开始，之后跟随0个或多个小写字符或数字。为了方便，“add”，“let”，“mult"会被定义为"关键字”，不会在表达式的变量命名中出现。
最后，要说一下作用域的概念。计算变量名所对应的表达式时，在计算上下文中，首先检查最内层作用域（按括号计），然后按顺序依次检查外部作用域。我们将保证每一个测试的表达式都是合法的。有关作用域的更多详细信息，请参阅示例。

385. 迷你语法分析器
给定一个用字符串表示的整数的嵌套列表，实现一个解析它的语法分析器。
列表中的每个元素只可能是整数或整数嵌套列表
提示：你可以假定这些字符串都是格式良好的：
字符串非空
字符串不包含空格
字符串只包含数字0-9、[、-、,、]

445. 两数相加 II
给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
链表或栈都可实现

341. 扁平化嵌套列表迭代器
给你一个嵌套的整数列表 nestedList 。每个元素要么是一个整数，要么是一个列表；该列表的元素也可能是整数或者是其他列表。请你实现一个迭代器将其扁平化，使之能够遍历这个列表中的所有整数。
实现扁平迭代器类 NestedIterator ：
NestedIterator(List nestedList) 用嵌套列表 nestedList 初始化迭代器。
int next() 返回嵌套列表的下一个整数。
boolean hasNext() 如果仍然存在待迭代的整数，返回 true ；否则，返回 false 。
我们可以先遍历整个嵌套列表，将所有整数存入一个数组，然后遍历该数组从而实现 \texttt{next}next 和 \texttt{hasNext}hasNext 方法。
深度优先搜索,栈，递归，迭代

678. 有效的括号字符串
给定一个只包含三种字符的字符串：（ ，） 和 *，写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则：
任何左括号 ( 必须有相应的右括号 )。
任何右括号 ) 必须有相应的左括号 ( 。
左括号 ( 必须在对应的右括号之前 )。
星号可以被视为单个右括号 ) ，或单个左括号 ( ，或一个空字符串。
一个空字符串也被视为有效字符串。

856. 括号的分数
给定一个平衡括号字符串 S，按下述规则计算该字符串的分数：
() 得 1 分。
AB 得 A + B 分，其中 A 和 B 是平衡括号字符串。
(A) 得 2 * A 分，其中 A 是平衡括号字符串。

1996. 游戏中弱角色的数量
你正在参加一个多角色游戏，每个角色都有两个主要属性：攻击 和 防御 。给你一个二维整数数组 properties ，其中 properties[i] = [attacki, defensei] 表示游戏中第 i 个角色的属性。
如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级，则认为该角色为 弱角色 。更正式地，如果认为角色 i 弱于 存在的另一个角色 j ，那么 attackj > attacki 且 defensej > defensei 。
返回 弱角色 的数量。

将角色按照攻击从大到小排序，攻击相同的按照防御从小到大排序。

然后遍历数组，维护遍历过的角色的防御的最大值maxDef。
对于当前角色 p，如果 p 的防御小于maxDef，说明当前角色位弱角色
【9，1】【9，2】，【9，3】，【8，1】，【8，2】

32. 最长有效括号
    给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

栈的使用

316. 去除重复字母
     给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。
     注意：该题与 1081 https://leetcode-cn.com/problems/smallest-subsequence-of-distinct-characters 相同
     思路：找出最小的满足 s[i]>s[i+1]的下标 i，并去除字符 s[i]
     从前向后扫描原字符串。保存起出现次数和位置。
     再次遍历时，判断是否要去掉当前字符。
     美访问一个字符，其对应的次数减一
     如果当前字符s[i]比栈顶元素小，且可访问次数大于0，则去除栈顶。
     如果当前字符比栈顶大，入栈。

def removeDuplicateLetters(self, s):
        vis = [0 for i in range(26)] # 存放是否已经在栈中
        num = [0 for i in range(26)] # 存放可访问字符次数
        for s_i in s:
            num[ord(s_i) - ord('a')] += 1

        stack = []
        for s_i in s:
            index = ord(s_i) - ord('a')
            if vis[index] == 0: # 还没有在栈中
                while len(stack) > 0 and stack[-1] > s_i: #如果比栈顶元素小
                    if nums[ord(stack[-1]) - ord('a')] > 0: #且栈顶元素还在后面可访问
                        vis[ord(stack[-1]) - ord('a')] = 0 #从栈中删除栈顶
                        stack = stack[:-1]
                    else:
                        break
                vis[index] = 1 # 加入当前元素到栈中
                stack.append(s_i)
            num[index] -= 1 # 当前元素可访问次数减一
        return "".join(stack)

402. 移掉 K 位数字
给你一个以字符串表示的非负整数 num 和一个整数 k ，移除这个数中的 k 位数字，使得剩下的数字最小。请你以字符串形式返回这个最小的数字。

numStack = []      
# 构建单调递增的数字串
for digit in num:
    while k and numStack and numStack[-1] > digit:
        numStack.pop()
        k -= 1
    numStack.append(digit)

# 如果 K > 0，删除末尾的 K 个字符
finalStack = numStack[:-k] if k else numStack

# 抹去前导零
return "".join(finalStack).lstrip('0') or "0"

581. 最短无序连续子数组
给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。
请你找出符合题意的 最短 子数组，并输出它的长度。
方法一：排序
我们将给定的数组nums 表示为三段子数组拼接的形式，分别记作 numsA，numsB，numsC。当我们对numsB进行排序，整个数组将变为有序。因此我们将原数组 \textit{nums}nums 排序与原数组进行比较，取最长的相同的前缀为numsA，取最长的相同的后缀为numsC，这样我们就可以取到最短的numsB。
方法二：
我们可以从大到小枚举 i，用一个变量minn 记录left。
同理，我们可以用类似的方法确定right。在实际代码中，我们可以在一次循环中同时完成左右边界的计算。
for i in range(n):
if maxn > nums[i]:
right = i
else:
maxn = nums[i]
if min < nums[n-1-i]:
left = i
else:
minn = nums[n-1-i]
return right == -1 ? 0 : right - left + 1;
方法三：单调栈
// 单调栈从前往后遍历一遍可得到左边界
// 单调栈从后往前遍历一遍可得到右边界

321. 拼接最大数
给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。
求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。
说明: 请尽可能地优化你算法的时间和空间复杂度。

def maxNumber(self, nums1, nums2, k):
	for i in range(start, end + 1):
	    subsequence1 = self.getMaxSubsequence(nums1, i)
	    subsequence2 = self.getMaxSubsequence(nums2, k - i)
	    curMaxSubsequence = self.merge(subsequence1, subsequence2)
	    if self.compare(curMaxSubsequence, 0, maxSubsequence, 0) > 0:
	        maxSubsequence = curMaxSubsequence
	return maxSubsequence
def getMaxSubsequence(self, nums, k):
        stack = [0] * k
        top = -1
        remain = len(nums) - k
        for i, num in enumerate(nums):
            while top >= 0 and stack[top] < num and remain > 0:
                top -= 1
                remain -= 1
            if top < k - 1:
                top += 1
                stack[top] = num
            else:
                remain -= 1
        return stack

456. 132 模式
给你一个整数数组 nums ，数组中共有 n 个整数。132 模式的子序列 由三个整数 nums[i]、nums[j] 和 nums[k] 组成，并同时满足：i < j < k 和 nums[i] < nums[k] < nums[j] 。
如果 nums 中存在 132 模式的子序列 ，返回 true ；否则，返回 false 。

我们从后往前做，维护一个「单调递减」的栈，同时使用 k 记录所有出栈元素的最大值（k 代表满足 132 结构中的 2）。
那么当我们遍历到 i，只要满足发现满足 nums[i] < k，说明我们找到了符合条件的 i j k。

stack = []
k = -(10 ** 9 + 7)
for i in range(len(nums) - 1,-1,-1):
    if nums[i] < k:
        return True
    while stack and stack[-1] < nums[i]:
        k = max(k,stack.pop())
    stack.append(nums[i])
return False

895. 最大频率栈
实现 FreqStack，模拟类似栈的数据结构的操作的一个类。
FreqStack 有两个函数：
push(int x)，将整数 x 推入栈中。
pop()，它移除并返回栈中出现最频繁的元素。
如果最频繁的元素不只一个，则移除并返回最接近栈顶的元素。

class FreqStack(object):
  def __init__(self):
      self.freq = collections.Counter()
      self.group = collections.defaultdict(list)
      self.maxfreq = 0

  def push(self, x):
      f = self.freq[x] + 1
      self.freq[x] = f
      if f > self.maxfreq:
          self.maxfreq = f
      self.group[f].append(x)

  def pop(self):
      x = self.group[self.maxfreq].pop()
      self.freq[x] -= 1
      if not self.group[self.maxfreq]:
          self.maxfreq -= 1

      return x

二叉树遍历

二叉树先序遍历
114. 二叉树展开为链表
给你二叉树的根结点 root ，请你将它展开为一个单链表：
展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树 先序遍历 顺序相同。

node = root;
while len(stack) > 0 or node != None:
    while node != None:
        res.append(node);
        stack.push(node);
        node = node.left;
    node = stack.pop();
    node = node.right;

N叉树先序遍历
589. N 叉树的前序遍历
给定一个 N 叉树，返回其节点值的 前序遍历 。
N 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。
进阶：
递归法很简单，你可以使用迭代法完成此题吗?

stack = [root]
ret = []
while len(stack) > 0:
    node = stack[-1]
    stack = stack[:-1]
    ret.append(node.val)
    for i in range(len(node.children)-1, -1, -1):
        stack.append(node.children[i])
return ret

94. 二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。

def track(self, root):
       node = root
       while len(stack) > 0 or node != None:
           while node:
               stack.append(node)
               node = node.left

           if len(stack) > 0:
               node = stack.pop()
               self.res.append(node.val)
               node = node.right

145. 二叉树的后序遍历
给定一个二叉树，返回它的 后序 遍历。

while root or stack:
    while root:
        stack.append(root)
        root = root.left
    root = stack.pop()
    if not root.right or root.right == prev:
        res.append(root.val)
        prev = root
        root = None
    else:
        stack.append(root)
        root = root.right

# 前右左 颠倒获得后序
stack = []
ret = []
node = root
while len(stack) > 0 or node != None:
    while node != None:
        ret.append(node.val)
        stack.append(node)
        node = node.right
    node = stack[-1]
    stack = stack[:-1]
    node = node.left
res = []
for i in range(len(ret)-1, -1, -1):
    res.append(ret[i])
return res

590. N 叉树的后序遍历
给定一个 N 叉树，返回其节点值的 后序遍历 。
N 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。
进阶：
递归法很简单，你可以使用迭代法完成此题吗?

stack = [root]
ret = []
while len(stack) > 0:
    node = stack[-1]
    stack = stack[:-1]
    ret = [node.val] + ret

    for node_i in node.children:
        stack.append(node_i)
return ret

中序遍历
173. 二叉搜索树迭代器
实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
int next()将指针向右移动，然后返回指针处的数字。
注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

331. 验证二叉树的前序序列化
     序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。
     9
     /
     3 2
     / \ /
     4 1 # 6
     / \ / \ /
     例如，上面的二叉树可以被序列化为字符串 “9,3,4,#,#,1,#,#,2,#,6,#,#”，其中 # 代表一个空节点。

给定一串以逗号分隔的序列，验证它是否是正确的二叉树的前序序列化。编写一个在不重构树的条件下的可行算法。

每个以逗号分隔的字符或为一个整数或为一个表示 null 指针的 ‘#’ 。

你可以认为输入格式总是有效的，例如它永远不会包含两个连续的逗号，比如 “1,3” 。

多个栈计算

155. 最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
辅助栈，存储栈的最小元素

32. 最长有效括号
给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
动态规划
s[i]=‘)’ 且 s[i−1]=‘(’. : dp[i]=dp[i−2]+2
s[i]=‘)’ 且 s[i−1]=‘)’，如果 s[i−dp[i−1]−1]=‘(’，那么
dp[i]=dp[i−1]+dp[i−dp[i−1]−2]+2
栈：
对于遇到的每个‘(’ ，我们将它的下标放入栈中
对于遇到的每个‘)’ ，判断其匹配的起始位置
由于每个合法的都不会相交。所以可以在右括号匹配

42. 接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
动态规划：
遍历，获得cur左边最高和右边最高，min为当前位置最终雨水的量
计算每个位置的雨水
栈：
维护一个单调栈，单调栈存储的是下标，栈底到栈顶递减。
从左到右遍历数组，遍历到下标 i 时，
如果栈内元素 >= 2，记栈顶元素为 top，第二个元素为left，则一定有height[left]≥height[top]。如果 height[i]>height[top]，则得到一个可以接雨水的区域，该区域的宽度是i−left−1，高度是min(height[left],height[i])−height[top]，根据宽度和高度即可计算得到该区域能接的雨水量。
为了得到left，需要将top 出栈。在对top 计算能接的雨水量之后，left 变成新的top，重复上述操作，直到栈变为空，或者栈顶下标对应的 height 中的元素大于或等于height[i]。
在对下标 i处计算能接的雨水量之后，将 i 入栈，继续遍历后面的下标，计算能接的雨水量。遍历结束之后即可得到能接的雨水总量

84. 柱状图中最大的矩形
给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。
动态规划：
计算最小值时的面积，根据最小值分割为多个部分，对多个部分分别计算最大面积
栈：
遍历，左右两侧最近的高度小于cur的柱子，求出当前位置作为高能够获得的面积

85. 最大矩形
给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
对每一行。计算每个位置向上1的情况，获得一个list
同柱状图中最大的矩形

栈的实现

225. 用队列实现栈
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

方法一：两个队列
queue1用于存储栈内的元素，queue2作为入栈操作的辅助队列。
入栈操作时，首先将元素入队到queue2，然后将queue1的全部元素依次出队并入队到queue2，再将 queue1和queue2互换，则queue1的前端和后端分别对应栈顶和栈底。
方法二：一个队列
入栈操作时，首先获得入栈前的元素个数 n，然后将元素入队到队列，再将队列中的前 n 个元素（即除了新入栈的元素之外的全部元素）依次出队并入队到队列，此时队列的前端的元素即为新入栈的元素，且队列的前端和后端分别对应栈顶和栈底。

232. 用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

面试题 03.01. 三合一
三合一。描述如何只用一个数组来实现三个栈。
你应该实现push(stackNum, value)、pop(stackNum)、isEmpty(stackNum)、peek(stackNum)方法。stackNum表示栈下标，value表示压入的值。
构造函数会传入一个stackSize参数，代表每个栈的大小。

栈顶标志（下一个入栈数要放的地方）：
0+3i, 1+3i, 2+3i
这样超出数组length最好计算
栈顶元素：
0+3i-3, 1+3i-3, 2+3i-3

将数组分成三份，每一份表示一个栈；使用三个index；在每次push，pop的时候，都改变index的值。从下标0开始存储数组。
第一个栈index1 in [0,stackSize)
第二个栈index2 in [stackSize,stackSize2)
第三个栈index3 in [stackSize2,stackSize*3)

2 739. 每日温度（中等） 暴力解法 + 单调栈
3 496. 下一个更大元素 I（简单） 暴力解法、单调栈
4 316. 去除重复字母（困难） 栈 + 哨兵技巧（Java、C++、Python）
5 901. 股票价格跨度（中等） 「力扣」第 901 题：股票价格跨度（单调栈）
6 402. 移掉K位数字
7 581. 最短无序连续子数组