【Leecode】代码随想录栈和队列篇day11(相互实现&去除重复）

java中栈Stack<>的底层实现使vector而vector可以扩容的特性其实不满足栈本身先进先出的特性，因此常常使用栈

相互实现

栈实现队列

• 题目链接：栈实现队列
• 我的解法：

class MyQueue {

    Stack<Integer> stackIn;
    Stack<Integer> stackOut;

    //初始化两栈模拟的队列
    public MyQueue() {
        stackIn = new Stack<>(); // 负责进栈
        stackOut = new Stack<>(); // 负责出栈
    }
    
    //入栈
    public void push(int x) {
        stackIn.push(x);
    }
    
    //出栈
    public int pop() {    
        dumpstackIn();
        return stackOut.pop();
    }
    
    //取栈顶元素
    public int peek() {
        dumpstackIn();
        return stackOut.peek();
    }
    
    //判空，两个栈都空才为空
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }

    // 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中
    private void dumpstackIn(){
        if (!stackOut.isEmpty()) return; 
        while (!stackIn.isEmpty()){
                stackOut.push(stackIn.pop());
        }
    }
}

队列实现栈

• 题目链接：队列实现栈
• 我的解法：

class MyStack {
    Queue<Integer> queue;
    
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);
    }
    
    public int pop() {
        rePosition();
        return queue.poll();
    }
    
    public int top() {
        rePosition();
        int result = queue.poll();
        queue.add(result);
        return result;
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }

    public void rePosition(){
        int size = queue.size();
        size--;
        while(size-->0)
            queue.add(queue.poll());
    }
}

去除重复

• 题目链接：去除重复括号
• 我的解法：

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //碰到左括号，就把相应的右括号入栈
            if (ch == '(') {
                deque.push(')');
            }else if (ch == '{') {
                deque.push('}');
            }else if (ch == '[') {
                deque.push(']');
            } else if (deque.isEmpty() || deque.peek() != ch) {
                return false;
            }else {//如果是右括号判断是否和栈顶元素匹配
                deque.pop();
            }
        }
        //最后判断栈中元素是否匹配
        return deque.isEmpty();
    }
}

• 复杂度：时间复杂度$O(n)$，空间复杂度$O(n)$

• 题目链接：去除字符串相邻重复字符

• 我的解法：

class Solution {
    public String removeDuplicates(String s) {
        char[] cs = s.toCharArray();
        Deque<Character> d = new ArrayDeque<>();
        for (char c : cs) {
            if (!d.isEmpty() && d.peekLast().equals(c)) {
                d.pollLast();
            } else {
                d.addLast(c);
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!d.isEmpty()) sb.append(d.pollFirst());
        return sb.toString();
    }
}

• 复杂度：时间复杂度$O(n)$，空间复杂度$O(n)$