小白学java栈的经典算法问题—

内容	1.括号匹配问题
	2.最小栈
	3.最大栈

1.括号匹配问题

栈的典型题目还是非常明显的，括号匹配、表达式计算等等几乎都少不了栈，本小节我们就看两个最经典的问题

首先是LeetCode20,链接

本道题还是比较简单的，其中比较麻烦的是如何判断两个符号是不是一组的

我们可以用哈希表将所有符号先存储，左半边做key，右半边做 value。遍历字符串的时候，遇到左半边符号就入栈，遇到右半边符号就与栈顶的符号比较，不匹配就返回false

class Solution {// 定义一个映射表，用于匹配括号private static final Map<Character, Character> map = new HashMap<Character, Character>() {{put('{', '}');put('[', ']');put('(', ')');put('?', '?');}};public boolean isValid(String s) {// 若字符串长度大于0且首字符不在映射表中，则直接返回falseif (s.length() > 0 && !map.containsKey(s.charAt(0))) {return false;}// 使用链表作为栈的实现，初始化时添加一个占位符'?'LinkedList<Character> stack = new LinkedList<Character>() {{add('?');}};// 遍历字符串中的每个字符for (Character c : s.toCharArray()) {if (map.containsKey(c)) {  // 若字符为左括号，则将其入栈stack.addLast(c);} else if (map.get(stack.removeLast()) != c) {  // 若字符为右括号，则与栈顶字符进行匹配return false;}}// 最终，若栈中只剩下一个占位符'?'，则所有括号都匹配成功return stack.size() == 1;}
}

这种问题使用java还是比较方便，但是对于C语言就非常不友好，需要自己构造，然后再实现算法。

LeetCode给我们制造了十几个括号匹配问题，但是都是条件变来变去，解决起来有难有易。

例如，LeetCode22链接

代码如下：

import java.util.ArrayList;
import java.util.List;public class Solution {// 做减法public List<String> generateParenthesis(int n) {List<String> res = new ArrayList<>();// 特判if (n == 0) {return res;}// 执行深度优先遍历，搜索可能的结果dfs("", n, n, res);return res;}/*** 执行深度优先遍历，搜索可能的括号组合* @param curStr 当前递归得到的结果* @param left   剩余可用的左括号个数* @param right  剩余可用的右括号个数* @param res    结果集*/private void dfs(String curStr, int left, int right, List<String> res) {// 因为每一次尝试，都使用新的字符串变量，所以无需回溯// 在递归终止的时候，直接把它添加到结果集即可，注意与「力扣」第 46 题、第 39 题区分if (left == 0 && right == 0) {res.add(curStr);return;}// 剪枝（如图，左括号可以使用的个数严格大于右括号可以使用的个数，才剪枝，注意这个细节）if (left > right) {return;}if (left > 0) {dfs(curStr + "(", left - 1, right, res); // 尝试放一个左括号}if (right > 0) {dfs(curStr + ")", left, right - 1, res); // 尝试放一个右括号}}
}

LeetCode32最长有效括号

class Solution {public int longestValidParentheses(String s) {int maxans = 0; // 最长有效括号的长度int[] dp = new int[s.length()]; // 用于存储以当前字符结尾的最长有效括号的长度for (int i = 1; i < s.length(); i++) {if (s.charAt(i) == ')') { // 当前字符为右括号时if (s.charAt(i - 1) == '(') { // 前一个字符为左括号时// 更新以当前字符结尾的最长有效括号的长度dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;} else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {// 当前字符前面有一段有效括号，且该段有效括号前面是左括号时// 更新以当前字符结尾的最长有效括号的长度dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;}maxans = Math.max(maxans, dp[i]); // 更新最长有效括号的长度}}return maxans; // 返回最长有效括号的长度}
}

LeetCode301链接

class Solution {private List<String> res = new ArrayList<String>(); // 用于存储有效的括号组合public List<String> removeInvalidParentheses(String s) {int lremove = 0; // 需要移除的左括号数量int rremove = 0; // 需要移除的右括号数量for (int i = 0; i < s.length(); i++) {if (s.charAt(i) == '(') {lremove++; // 统计左括号数量} else if (s.charAt(i) == ')') {if (lremove == 0) {rremove++; // 统计右括号数量，如果没有对应的左括号，则需要移除该右括号} else {lremove--; // 匹配到一个右括号，可以抵消一个左括号}}}helper(s, 0, lremove, rremove); // 辅助函数进行递归处理return res; // 返回有效的括号组合列表}private void helper(String str, int start, int lremove, int rremove) {if (lremove == 0 && rremove == 0) { // 当需要移除的括号数量为0时，判断当前字符串是否有效if (isValid(str)) {res.add(str); // 如果有效，则将其添加到结果列表中}return; // 结束递归}for (int i = start; i < str.length(); i++) {if (i != start && str.charAt(i) == str.charAt(i - 1)) {continue; // 避免重复计算，如果当前字符和前一个字符相同，则跳过}// 如果剩余的字符无法满足去掉的数量要求，直接返回if (lremove + rremove > str.length() - i) {return;}// 尝试去掉一个左括号if (lremove > 0 && str.charAt(i) == '(') {helper(str.substring(0, i) + str.substring(i + 1), i, lremove - 1, rremove);}// 尝试去掉一个右括号if (rremove > 0 && str.charAt(i) == ')') {helper(str.substring(0, i) + str.substring(i + 1), i, lremove, rremove - 1);}}}private boolean isValid(String str) {int cnt = 0; // 记录左括号和右括号的差值for (int i = 0; i < str.length(); i++) {if (str.charAt(i) == '(') {cnt++; // 遇到左括号，增加差值} else if (str.charAt(i) == ')') {cnt--; // 遇到右括号，减少差值if (cnt < 0) {return false; // 如果差值小于0，说明右括号多余左括号，无效}}}return cnt == 0; // 差值为0，说明左右括号一一对应，有效}
}

2.最小栈

LeetCoede155链接

本道题的关键在于理解getMin()到底表示什么，可以看一个例子上的示例画成示意图如下：

这里的关键是理解对应的Min栈内，中间元素为什么是-2，理解了本道题就非常简单。

题目要求在常数事件内获得栈的最小值，因此不能在getMin()的时候再去计算最小值，最好在push或者pop的时候就已经计算好了当前栈中的最小值。

对于栈来说，如果一个元素a在入栈时，栈里有其他元素的b,c,d，那么无论这个栈在之后经历了什么操作，只要a在栈中，b,c,d就一定在栈中，因为在a被弹出之前，b,c,d就不会被弹出。

那么，我们可以在每个元素a入栈的时候把当前栈的最小值m存储起来，在这之后无论何时，如果栈顶元素是a，我们就可以直接返回存储的最小值m。

按照上面的思路，我们只需要设计一个数据结构，使得每一个元素a与其相应的最小值m时刻保持一一对应，因此我们使用一个辅助栈，与元素栈同步插入与删除，用于存储与每个元素对应的最小值。

当一个元素要入栈的时候，我们取当前辅助栈的栈顶存储的最小值，与当前元素比较得出最小值，将这个最小值插入辅助栈中。
当一个元素要出栈的时候，我们把辅助栈的栈顶元素也一并弹出。
在任意一个时刻，栈内元素的最小值就存储在辅助栈的栈顶元素中。

/*** 实现一个最小栈 MinStack，支持 push、pop、top 和 getMin 操作*/
class MinStack {private Stack<Integer> stack;  // 存储栈元素的主栈private Stack<Integer> min_stack;  // 存储当前栈中最小值的辅助栈public MinStack() {stack = new Stack<>();min_stack = new Stack<>();}/*** 向栈中压入元素x* @param x 待压入的元素*/public void push(int x) {stack.push(x);  // 将元素压入主栈中if (min_stack.isEmpty() || x <= min_stack.peek()) {min_stack.push(x);  // 如果是最小值，则将其压入辅助栈中}}/*** 弹出栈顶元素*/public void pop() {if (stack.pop().equals(min_stack.peek())) {min_stack.pop();  // 如果是最小值，则从辅助栈中弹出}}/*** 获取栈顶元素* @return 栈顶元素*/public int top() {return stack.peek();  // 直接返回主栈的栈顶元素}/*** 获取栈中最小值* @return 栈中最小值*/public int getMin() {return min_stack.peek();  // 直接返回辅助栈的栈顶元素，即为栈中最小值}
}

3.最大栈

LeetCode716.设计一个最大栈数据结构，既支持栈操作，又支持查找栈中的最大元素。

实现MaxStack类：

MaxStack()初始化栈对象
void push(int x)将元素x压入栈中。
int pop（）移除栈顶元素并返回这个元素
int top()返回栈顶元素，无需移除
int peeMax()检索并返回栈中最大元素，无需移除。
int popMax()检查并返回栈中最大元素，并将其移除。
如果有多个元素，只要移除 最靠近栈顶的那个。

示例：

输入：
["MaxStack","push","push","top","popMax","top","premix","pop","top"]
[[],[5],[1],[5],[],[],[],[],[],[]]
输出：
[null,null,null,null,5,5,1,5,1,5]
解释：
MaxStack stk=new MaxStack();
stk.push(5);   //[5] - 5既是栈顶元素，也是最大元素
stk.push(1);   //[5，1】 - 栈顶元素是1，最大元素是5
stk.push(5);   //[5,1,5] - 5既是栈顶元素，也是最大元素
stk.top();     //返回 5，[5，1，5] - 栈没有改变
stk.popMax();  //返回 5，[5，1] - 栈发生改变，栈顶元素不再是最大元素
stk.top();    //返回 1，[5，1] - 栈没有改变
stk.popMax(); //返回 5，[5，1] - 栈没有改变
stk.pop();     //返回 1，[5] - 次操作后，5既是栈顶元素，也是最大元素
stk.top();    //返回5，[5] - 栈没有改变

本道题与上一题相反，但是处理方法是一致的，一个普通的栈可以支持前三种操作push(x)、pop()和top()，所以我们需要考虑的仅仅为后两种操作的peekMax()和popMax()。

对于peekMax()，我们可以另一个栈来存储每个位置到栈底的所有元素的最大值，例如，如果当前的第一个栈中元素为[2,1,5,3,9]，那么第二个栈中的额元素为[2,2,5,5,9]。在push(x)操作时，只需要将第二个栈的栈顶和x的最大值入栈，而在pop()操作时，只需要将第二个栈进行出栈。

对于popMax()，由于我们知道当前栈中最大的元素值，因此可以直接将两个栈同时出栈，并存储第一个栈出栈的所有值。当某个时刻，第一个栈的出栈元素就等于当前栈中最大的元素值时，就找到了最大的元素。这个时候我们将之前第一个栈的所有元素重新入栈，并且同步更新第二个栈，就完成了popMax()操作。

package com.yugutou.charpter4_stack.level2;import java.util.Stack;/*** 实现一个支持 push、pop、top、peekMax 和 popMax 操作的最大栈 MaxStack*/
class MaxStack {Stack<Integer> stack;  // 存储栈元素的主栈Stack<Integer> maxStack;  // 存储当前栈中最大值的辅助栈public MaxStack() {stack = new Stack();  // 初始化主栈maxStack = new Stack();  // 初始化最大值辅助栈}/*** 向栈中压入元素x* @param x 待压入的元素*/public void push(int x) {int max = maxStack.isEmpty() ? x : maxStack.peek();  // 获取当前最大值maxStack.push(max > x ? max : x);  // 将当前最大值或新元素压入最大值辅助栈stack.push(x);  // 将元素压入主栈}/*** 弹出栈顶元素* @return 弹出的栈顶元素*/public int pop() {maxStack.pop();  // 弹出最大值辅助栈的栈顶元素return stack.pop();  // 弹出主栈的栈顶元素}/*** 获取栈顶元素* @return 栈顶元素*/public int top() {return stack.peek();  // 直接返回主栈的栈顶元素}/*** 获取栈中最大值* @return 栈中最大值*/public int peekMax() {return maxStack.peek();  // 直接返回最大值辅助栈的栈顶元素，即为栈中最大值}/*** 弹出栈中的最大值* @return 被弹出的最大值*/public int popMax() {int max = peekMax();  // 获取当前栈中的最大值Stack<Integer> buffer = new Stack();  // 辅助栈用于暂存元素while (top() != max) {buffer.push(pop());  // 将非最大值的元素暂存到辅助栈中}pop();  // 弹出栈中的最大值while (!buffer.isEmpty()) {push(buffer.pop());  // 将暂存的元素重新压入栈中}return max;  // 返回被弹出的最大值}
}