栈：删除最外层的括号 (Leetcode 1021 / 155 / 1172 / 剑指31 / 面试 03.03)

 

 

 

 

 

 

 

 

 

/**
* 解法一：暴力解法思路分析
* 1.定义容器存储原语子串
* new ArrayList<String>();
* 2.定义左括号、右括号计数器：
* int left = 0, right = 0;
* 3.遍历字符串，读取到括号时对应计数器自增
* 4.检查是否到达原语结尾，截取原语子串并添加到容器中
* 5.遍历容器，删除最外层括号后合并成新串
*
* 边界问题：
* 遍历字符串，注意索引越界：i < S.length()
* 截取原语字符串时，注意起止索引：[start, end)
* 细节问题：
* 需要记录上一次截取原语子串之后的位置
* 删除原语子串的最外层括号，其实就是重新截取
* @param S
* @return
*/
public String removeOuterParentheses(String S) {
　　int len = S.length();
　　// 1.定义容器存储原语子串
　　List<String> list = new ArrayList<>();
　　// 2.定义左括号、右括号计数器
　　int left = 0, right = 0, lastOpr = 0;
　　// 3.遍历字符串，读取到括号时对应计数器自增
　　for (int i = 0; i < len; i++) {
　　　　char c = S.charAt(i);
　　　　if (c == '(') {
　　　　　　left++;
　　　　} else if (c == ')') {
　　　　　　right++;
　　　　}
　　　　// 4.检查是否到达某个原语结尾，截取原语子串添加到容器
　　　　if (left == right) {
　　　　　　list.add(S.substring(lastOpr, i + 1));
　　　　　　lastOpr = i + 1;
　　　　}
　　}
　　// 5.遍历容器中的原语子串，删除最外层后合并成新串
　　StringBuilder sb = new StringBuilder();
　　for (String s : list) {
　　　　sb.append(s.substring(1, s.length() - 1));
　　}
　　return sb.toString();
}

 

/**
* 解法二：优化解法思路分析
* 1.定义容器存储删除外层括号后的原语子串
* new StringBuilder();
* 2.定义左括号、右括号计数器：
* int left = 0, right = 0;
* 3.遍历字符串，读取到括号时对应计数器自增
* 4.检查是否到达原语结尾，截取不包含最外层的原语子串并拼接到容器中
*
* @param S
* @return
*/
public String removeOuterParentheses(String S) {
　　int len = S.length();
　　// 1.定义容器存储删除外层括号后的原语子串
　　StringBuilder sb = new StringBuilder();
　　// 2.定义左括号、右括号计数器
　　int left = 0, right = 0, lastOpr = 0;
　　// 3.遍历字符串，读取到括号时对应计数器自增
　　for (int i = 0; i < len; i++) {
　　　　char c = S.charAt(i);
　　　　if (c == '(') {
　　　　　　left++;
　　　　} else if (c == ')') {
　　　　　right++;
　　　　}
　　　　// 4.检查是否到达某个原语结尾，截取不包含最外层的原语子串添加到容器
　　　　if (left == right) {
　　　　　　sb.append(S.substring(++lastOpr, i));
　　　　　　lastOpr = i + 1;
　　　　}
　　}
　　return sb.toString();
}

 

 

 

 

/**
* 栈：后进先出
* @param <E>
*/
class Stack<E> {
　　Object[] elements = new Object[10000];
　　int index = -1; // 栈顶索引
　　int size = 0; // 栈中元素个数
　　public Stack() {
　　}
　　/**
　　* 往栈顶插入元素
　　* @param c
　　*/
　　public void push(E c) {
　　　　elements[++index] = c;
　　　　size++;
　　}
　　/**
　　* 从栈顶获取数据，不移出
　　栈解法优化，使用栈的思想，直接用数组取代栈：
　　* @return
　　*/
　　public E peek() {
　　　　if (index < 0) {
　　　　　　return null;
　　　　}
　　　　return (E)elements[index];
　　}
　　/**
　　* 从栈顶移出元素
　　* @return
　　*/
　　public E pop() {
　　　　E e = peek();
　　　　if (e != null) {
　　　　　　elements[index] = null; // 移出动作
　　　　　　index--; // 栈顶下移
　　　　　　size--;
　　　　}
　　return e;
}
　　public boolean isEmpty() {
　　　　return size == 0;
　　}
}

/**
* 最优解：栈解法
* 1.使用数组模拟一个栈，临时存储左括号字符
* push(Character) ; pop(); isEmpty()
* 2.遍历字符串，根据情况进行入栈/出栈操作
栈实现代码：
* 读取到左括号，左括号入栈
* 读取到右括号，左括号出栈
* 3.判断栈是否为空，若为空，找到了一个完整的原语
* 4.截取不含最外层括号的原语子串并进行拼接
*
* @param S
* @return
*/
public String removeOuterParentheses(String S) {
　　StringBuilder result = new StringBuilder();
　　// 1.使用数组模拟一个栈，临时存储字符，替代计数器
　　Stack stack = new Stack();
　　int lastOpr = 0;
　　// 2.遍历字符串，根据情况进行入栈 / 出栈操作
　　for (int i = 0; i < S.length(); i++) {
　　　　char ch = S.charAt(i);
　　　　if (ch == '(') { // 遇到左括号，左括号入栈
　　　　　　stack.push(ch);
　　　　} else if (ch == ')') { // 遇到右括号，左括号出栈
　　　　　　stack.pop(); // 栈顶的左括号出栈
　　　　}
　　　　// 3.判断栈是否为空，若为空，找到了一个完整的原语
　　　　if (stack.isEmpty()) {
　　　　　　// 4.截取不含最外层括号的原语子串并进行拼接
　　　　　　result.append(S.substring(lastOpr + 1, i));// 去掉原语的最外层括号并追加到结果
　　　　　　lastOpr = i + 1;// 往后找，再次初始化原语开始位置
　　　　}
　　}
　　return result.toString();
}

 

 

/**
* 最优解：代码优化：
* 1.直接用数组取代栈
* 创建数组、栈顶索引，使用数组操作入栈和出栈
* 2.将原字符串转为数组进行遍历
* char[] s = S.toCharArray();
* 3.去掉截取子串的操作，将原语字符直接拼接
* 读取到左括号：此前有数据，当前必属原语
* 读取到右括号：匹配后不为0，当前必属原语
* @param S
* @return
*/
public String removeOuterParentheses(String S) {
　　StringBuilder result = new StringBuilder();
　　// 1.直接用数组取代栈
　　int index = -1; // 栈顶索引
　　int len = S.length();
　　char[] stack = new char[len];
　　char[] s = S.toCharArray();
　　// 2.遍历字符串，根据情况进行入栈 / 出栈操作
　　for (int i = 0; i < len; i++) {
　　　　char ch = s[i];
　　　　if (ch == '(') { // 遇到左括号，左括号入栈
　　　　　　// 3.去掉截取子串的操作，将原语字符直接拼接
　　　　　　if (index > -1) { // 此前有数据，当前必属原语
　　　　　　　　result.append(ch);
　　　　　　}
　　　　　　stack[++index] = ch;
　　　　} else /*if (ch == ')')*/ { // 遇到右括号，左括号出栈
　　　　　　stack[index--] = 'u0000'; // 栈顶的左括号出栈
　　　　　　if (index > -1) {
　　　　　　　　result.append(ch);
　　　　　　}
　　　　}
　　}
　　return result.toString();
}

最最优解

 

 

 

 

Leetcode 155 -  最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) —— 将元素 x 推入栈中。
• pop() —— 删除栈顶的元素。
• top() —— 获取栈顶元素。
• getMin() —— 检索栈中的最小元素。

示例:

输入：
　　["MinStack","push","push","push","getMin","pop","top","getMin"]
　　[[],[-2],[0],[-3],[],[],[],[]]

输出：
　　[null,null,null,null,-3,null,0,-2]

解释：
　　MinStack minStack = new MinStack();
　　minStack.push(-2);
　　minStack.push(0);
　　minStack.push(-3);
　　minStack.getMin(); --> 返回 -3.
　　minStack.pop();
　　minStack.top(); --> 返回 0.　　
　　minStack.getMin(); --> 返回 -2.

提示：

• pop、top 和 getMin 操作总是在 非空栈 上调用。

//思路：使用两个队列实现最小栈
class MinStack { 
    Deque<Integer> xStack; //主栈，存放所有入栈数据
    Deque<Integer> minStack; //每次入栈当前最小数据
    public MinStack() {
        xStack = new LinkedList<Integer>();
        minStack = new LinkedList<Integer>();
        minStack.push(Integer.MAX_VALUE);//默认最小数据为整形最大值
    }

    public void push(int x) {
        xStack.push(x);//入栈
        minStack.push( minStack.peek()< x? minStack.peek():x); //将当前最小值入栈，为保证数量一致，所以会重复存放最小值
    }

    public void pop() {
        xStack.pop();//出栈
        minStack.pop();//当前最小值也出栈
    }

    public int top() {
        return xStack.peek();//获取栈顶元素
    }

    public int getMin() {
        return minStack.peek();//通过最小栈获取当前最小元素
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

剑指Offer 31 -  栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。
假设压入栈的所有数字均不相等。
例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，
但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

　　输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
　　输出：true
　　解释：我们可以按以下顺序执行：
　　push(1), push(2), push(3), push(4), pop() -> 4,
　　push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2：

　　输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
　　输出：false
　　解释：1 不能在 2 之前弹出。

提示：

　　0 <= pushed.length == popped.length <= 1000
　　0 <= pushed[i], popped[i] < 1000
　　pushed 是 popped 的排列。

//思路：每次比较栈顶元素与弹出序列是否一致，一致则出栈
class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
       Stack<Integer> stack = new Stack<>();
        int i = 0;
        for(int num : pushed) {
            stack.push(num); // num 入栈
            while(!stack.isEmpty() && stack.peek() == popped[i]) { // 循环判断与出栈
                stack.pop();
                i++;
            }
        }
        return stack.isEmpty();
    }
}

堆盘子 - 面试 03.03

堆盘子。设想有一堆盘子，堆太高可能会倒下来。

因此，在现实生活中，盘子堆到一定高度时，我们就会另外堆一堆盘子。请实现数据结构SetOfStacks，模拟这种行为。

SetOfStacks应该由多个栈组成，并且在前一个栈填满时新建一个栈。

此外，SetOfStacks.push()和SetOfStacks.pop()应该与普通栈的操作方法相同（也就是说，pop()返回的值，应该跟只有一个栈时的情况一样）。

进阶：实现一个popAt(int index)方法，根据指定的子栈，执行pop操作。

当某个栈为空时，应当删除该栈。当栈中没有元素或不存在该栈时，pop，popAt 应返回 -1.

示例1:

输入：
　　["StackOfPlates", "push", "push", "popAt", "pop", "pop"]
　　[[1], [1], [2], [1], [], []]
输出：
　　[null, null, null, 2, 1, -1]

示例2:

输入：
　　["StackOfPlates", "push", "push", "push", "popAt", "popAt", "popAt"]
　　[[2], [1], [2], [3], [0], [0], [0]]
输出：
　　[null, null, null, null, 2, 1, 3]

class StackOfPlates {
    private List<Stack<Integer>> stackList;
    private int cap;
    public StackOfPlates(int cap) {
        stackList = new ArrayList<>(); //使用ArrayList来存储所有的栈
        this.cap = cap;
    }

    public void push(int val) {
        if (cap <= 0) {//处理边界
            return;
        }

        if (stackList.isEmpty() || stackList.get(stackList.size() - 1).size() == cap) {//处理最后一个栈满的情况
            Stack<Integer> stack = new Stack<>();
            stack.push(val);
            stackList.add(stack);
            return;
        }

        stackList.get(stackList.size() - 1).push(val);
    }

    public int pop() {
        return popAt(stackList.size() - 1);
    }

    public int popAt(int index) {
        if (index < 0 || index >= stackList.size()) {
            return -1;
        }

        Stack<Integer> stack = stackList.get(index);
        if (stack.isEmpty()) {
            return -1;
        }

        int res = stack.pop();

        if (stack.isEmpty()) {
            stackList.remove(index);
        }

        return res;
    }
}

餐盘栈 - Leetcode 1172

我们把无限数量 ∞ 的栈排成一行，按从左到右的次序从 0 开始编号。每个栈的的最大容量 capacity 都相同。

实现一个叫「餐盘」的类 DinnerPlates：

DinnerPlates(int capacity) - 给出栈的最大容量 capacity。
void push(int val) - 将给出的正整数 val 推入 从左往右第一个 没有满的栈。
int pop() - 返回 从右往左第一个 非空栈顶部的值，并将其从栈中删除；如果所有的栈都是空的，请返回 -1。
int popAtStack(int index) - 返回编号 index 的栈顶部的值，并将其从栈中删除；如果编号 index 的栈是空的，请返回 -1。

示例：

输入：
　　["DinnerPlates","push","push","push","push","push","popAtStack","push","push","popAtStack","popAtStack","pop","pop","pop","pop","pop"]
　　[[2],[1],[2],[3],[4],[5],[0],[20],[21],[0],[2],[],[],[],[],[]]
输出：
　　[null,null,null,null,null,null,2,null,null,20,21,5,4,3,1,-1]

解释：
DinnerPlates D = DinnerPlates(2); // 初始化，栈最大容量 capacity = 2
D.push(1);
D.push(2);
D.push(3);
D.push(4);
D.push(5); // 栈的现状为：
2 4
1 3 5
﹈ ﹈ ﹈
D.popAtStack(0); // 返回 2。栈的现状为：
4
1 3 5
﹈ ﹈ ﹈
D.push(20); // 栈的现状为：
20 4
1 3 5
﹈ ﹈ ﹈
D.push(21); // 栈的现状为：
20 4 21
1 3 5
﹈ ﹈ ﹈
D.popAtStack(0); // 返回 20。栈的现状为：
4 21
1 3 5
﹈ ﹈ ﹈
D.popAtStack(2); // 返回 21。栈的现状为：
4
1 3 5
﹈ ﹈ ﹈
D.pop() // 返回 5。栈的现状为：
4
1 3
﹈ ﹈
D.pop() // 返回 4。栈的现状为：
1 3
﹈ ﹈
D.pop() // 返回 3。栈的现状为：
1
﹈
D.pop() // 返回 1。现在没有栈。
D.pop() // 返回 -1。仍然没有栈。

//采用双指针思想，后面后讲到的
class DinnerPlates {
    private int capacity = 0;
    private int left = 0;//从左边开始第一个不满的，严格控制
    private int right = 0;//从右边开始第一个非空的，宽松
    private List<Stack<Integer>> list = new ArrayList<>();

    public DinnerPlates(int capacity) {
        this.capacity = capacity;
        Stack<Integer> stack2 = new Stack();
        list.add(stack2);
    }

    /*
        直接在left所在位置进行入栈，push后需要遍历查找下一个未满栈
        细节问题：
            1. 需要对list进行扩容操作
            2. 需要更新right位置（right宽松，不保证一定是非空，可以在第一个非空的右边）
     */
    public void push(int val) {
        if (left < 0)
            left = 0;
        Stack<Integer> stack = list.get(left);
        stack.push(val);
        //达到容量，则找后面的第一个未满栈
        while (left < list.size() && list.get(left).size() == capacity) {
            left++;
        }

        if (left >= list.size()) { //需要增加栈的数量
            Stack<Integer> stack2 = new Stack();
            list.add(stack2);
        }

        if (right < left) { //新的栈在right以右，更新right的位置
            right = left;
        }
    }

    /*
        以right为起点，往左遍历查找第一个非空栈
        细节问题：
            移除数据后，需要判断所在位置是不是比left更小，如果满足则需要更新left
            移除数据后，需要判断所在位置是不是空栈，空栈则将right左移一个（right宽松，不保证一定是非空，可以在第一个非空的右边）
     */
    public int pop() {
        for (int i = right; i >= 0; i--) {//从right开始找第一个非空栈，乐观情况right就是想要的位置
            Stack<Integer> stack = list.get(i);
            if (!stack.isEmpty()) {
                right = i;
                Integer val = stack.pop();
                if (left > right) { //如果移除的位置在left左边，需要将left修复到right位置
                    left = right;
                }
                if (stack.isEmpty()) {//pop之后，right需要再向左移动一个（这里不保证right的新位置一定为非空栈）
                    right--;
                }
                return val;
            }
        }
        return -1;
    }

    /*
      移除数据后，需要判断所在位置是不是比left更小，如果满足则需要更新left
     */
    public int popAtStack(int index) {
        if (index > list.size() - 1) //越界检查
            return -1;
        Stack<Integer> stack = list.get(index);
        if (!stack.isEmpty()) { //栈不为空
            if (left > index) { //在左边界之前，更新左边界执行更靠左的未满栈
                left = index;
            }
            return stack.pop();
        } else {
            return -1;
        }
    }
}
/**
 * Your DinnerPlates object will be instantiated and called as such:
 * DinnerPlates obj = new DinnerPlates(capacity);
 * obj.push(val);
 * int param_2 = obj.pop();
 * int param_3 = obj.popAtStack(index);
 */