代码随想录算法训练营第十天|栈与队列理论基础 232.用栈实现队列 225. 用队列实现栈 20. 有效的括号 1047. 删除字符串中的所有相邻重复项

栈与队列理论基础

在java里 栈是由deque接口实现类ArrayDeque来实现栈功能 它基于动态数组

队列（queue）是由链表（LinkedList）实现 它基于链表结构 提供高效的入队出队操作

循环队列：基于数组实现的队列 循环利用数组空间循环来提高空间使用率

232.用栈实现队列

题目链接：232. 用栈实现队列 - 力扣（LeetCode）

讲解链接：栈的基本操作！ | LeetCode：232.用栈实现队列

 对deque进行操作 JAVA

Java代码：

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());
        }
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

 225. 用队列实现栈

题目链接：225. 用队列实现栈 - 力扣（LeetCode）

讲解链接：代码随想录

用队列实现栈！

Java代码：

class MyStack {

    Queue<Integer> queue1;//和栈里保持一致的元素的队列
    Queue<Integer> queue2;//辅助队列

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        queue2.offer(x);//先放在辅助队列里
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
            //将queue1的队头元素出队，并添加到queue2的队尾。
        }
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp;///最后交换queue1和queue2 把元素都放到queue1里
    }

    public int pop() {
        return queue1.poll();//因为qyeue1中的元素和栈里的保持一致 所以这个和下面的两个操作只看queue1
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

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

20. 有效的括号 

题目链接：20. 有效的括号 - 力扣（LeetCode）

讲解链接：代码随想录

直接开始写代码 经典题 栈结构的特殊性 非常适合做对称匹配类的题目

第一种情况 字符串里左方向的括号多余了 所以不匹配。

第二种情况 括号没有多余 但是 括号的类型没有匹配上

第三种情况 字符串里右方向的括号多余了 所以不匹配

如图 引于代码随想录：

Java代码：

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();
    }
}

1047. 删除字符串中的所有相邻重复项

题目链接：1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）

讲解链接：代码随想录

先看题 删除所有相邻重复项  就像这样：（代码随想录图示）

 

Java代码：

class Solution {
    public String removeDuplicates(String s) {
        //ArrayDeque会比LinkedList在出来删除元素这一点外会快一些
        ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for(int i = 0; i < s.length(); i++){
            ch = s.charAt(i);
            if(deque.isEmpty() || deque.peek() != ch){
                deque.push(ch);
            }else{
                deque.pop();
            }
        }
        String str = "";
        //剩余的元素即是不重复的元素
        while(!deque.isEmpty()){
            str = deque.pop() + str;
        }
        return str;
    }
}

OK了 结束打卡