数据结构-LeetCode刷题(栈与队列）

(LeetCode 232)用栈实现队列

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

你只能使用标准的栈操作，也就是只有 push to top, peek/pop from top, size, 和 isempty 操作是合法的。你所使用的语言也许不支持栈。你可以使用 list 或者deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

方法 两个栈实现

栈是先进后出，队列是先进先出。而如何用栈实现队列就要用到输入栈和输出栈两个栈。
当队列输入时，数据放入输入栈中；
当队列输出时，数据先从输入栈取出，放入输出栈，再从输出栈取出（重点）
这样就实现了队列的先入先出。

• 问题已理解

class MyQueue {

    private static Stack<Integer> inStack;
    private static Stack<Integer> outStack;

    public MyQueue() {
        inStack = new Stack<Integer>();
        outStack = new Stack<Integer>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if(outStack.isEmpty()){
            in2out();
        }
        return outStack.pop();
    }

    public int peek() {
        if(outStack.isEmpty()){
            in2out();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }
    
    private void in2out(){
        while (!inStack.isEmpty()){
            outStack.push(inStack.pop());
        }
    }
}

(LeetCode 394)字符串解码

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

方法 栈（一个确定字符串字符位置的变量）

遍历传入的字符串，准备传入另一个栈。会有三种遇到的情况：
①遍历到的字符串是数字，继续遍历，防止出现的是多位数。处理完入栈。
②遍历到的字符串是字母或"["，直接入栈。
③遍历到的字符串是"]"，将入栈的数据出栈，直到遇到"]"
（这之间的数据就是字母，由于出栈会导致顺序颠倒，所以用
LinkedList sub = new LinkedList<>(); 接受字符串
Collections.reverse(sub); 反转字符串）
反转后，左括号也要出栈，此时栈顶的数字就是该字母段要重复的次数，处理后再入栈
如此循环，直到遍历到字符串尾。

• 问题已理解

 
class Solution {
    int ptr;
    
    public String decodeString(String s) {
        LinkedList<String> stk = new LinkedList<>();
        ptr = 0;
        while (ptr < s.length()){
            char cur = s.charAt(ptr);
            if(Character.isDigit(cur)){
                //处理数字，使数字完整
                String digits = getDigits(s);
                stk.add(digits);
            }else if(Character.isLetter(cur) || cur == '['){
                //处理普通字符和"["
                stk.addLast(String.valueOf(s.charAt(ptr++)));
            }else{
                //遇到"]"，处理与之相匹配的"["之间的字符
                ++ptr;
                //用另一个list，将字符串进行组合
                LinkedList<String> sub = new LinkedList<>();
                while (!"[".equals(stk.peekLast())){
                    sub.addLast(stk.removeLast());
                }
                //反转组合出来的字符串
                Collections.reverse(sub);
                //左括号出栈
                stk.removeLast();
                //此时的栈顶是对应字符出现的次数
                int repTime = Integer.parseInt(stk.removeLast());
                StringBuffer t = new StringBuffer();
                String o = getString(sub);
                //构造字符串
                while (repTime-- > 0){
                    t.append(o);
                }
                //构造好的字符串入栈
                stk.addLast(t.toString());
            }
        }
        return getString(stk);
    }

    public String getDigits(String s){
        StringBuffer ret = new StringBuffer();
        while (Character.isDigit(s.charAt(ptr))){
            ret.append(s.charAt(ptr++));
        }
        return ret.toString();
    }
    private String getString(LinkedList<String> v) {
        StringBuffer ret = new StringBuffer();
        for (String s :v){
            ret.append(s);
        }
        return ret.toString();
    }
}