代码随想录| 232.用栈实现队列225. 用队列实现栈20. 有效的括号 1047. 删除字符串中的所有相邻重复项

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

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

        }

        public void push(int x) {
            stackIn.add(x);
        }

        public int pop() {
            if(stackOut.isEmpty()) {
                while (!stackIn.isEmpty())
                    stackOut.add(stackIn.pop());
            }
            return stackOut.pop();
        }

        public int peek() {
            if(stackOut.isEmpty()){
                while(!stackIn.isEmpty())
                    stackOut.add(stackIn.pop());
            }
            return stackOut.peek();
        }

        public boolean empty() {
            return stackOut.isEmpty()&&stackIn.isEmpty();
        }
    }
    //请你仅使用1个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
    //实现 MyStack 类：
    //void push(int x) 将元素 x 压入栈顶。
    //int pop() 移除并返回栈顶元素。
    //int top() 返回栈顶元素。
    //boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
    class MyStack {
    Queue<Integer> queue=new LinkedList<>();
    int count=0;
        public MyStack() {

        }

        public void push(int x) {
            queue.add(x);
            count++;
        }
        public int pop() {
            for(int i=0;i<count-1;i++){//每次将队列输出的再次输入队列后部
依照循环，每次将最后一个入队列的弹出
                queue.add(queue.poll());
            }
            if(!queue.isEmpty())
                count--;
            return queue.poll();
        }

        public int top() {
            for(int i=0;i<count-1;i++){
                queue.add(queue.poll());
            }
            int result=queue.peek();
            queue.add(queue.poll());//要再次将最后一个拿出放到队列后面不让会改变最初添加的顺序
            return result;
        }

        public boolean empty() {
            return queue.isEmpty();
        }
    }
    //给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
    //有效字符串需满足：
    //左括号必须用相同类型的右括号闭合。
    //左括号必须以正确的顺序闭合。
    //每个右括号都有一个对应的相同类型的左括号
    public boolean isValid(String s) {
        Stack<String> stack=new Stack<>();
        for(int i=0;i<s.length();i++){//一直遍历s为左括号就在栈中添加对应的右括号，当遍历到右括号时就用peek方法，看看与栈顶的右括号是否相同，相同即可弹出栈，不同返回false
            if(s.charAt(i)=='{'){
                stack.add('}'+"");
            } else if (s.charAt(i)=='(') {
                stack.add(')'+"");
            } else if (s.charAt(i)=='[') {
                stack.add(']'+"");
            }
            else{
                if((!stack.isEmpty())&&stack.peek().equals(s.charAt(i)+"")){
                    stack.pop();
                }
                else return false;
            }
        }
        return stack.isEmpty();//避免左括号多的情况
    }
    //给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
    //在 S 上反复执行重复项删除操作，直到无法继续删除。
    //在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
    public String removeDuplicates(String s) {
        Stack<Character> stack=new Stack<>();
        StringBuilder str= new StringBuilder();
        for(int i=0;i<s.length();i++){
            if(stack.isEmpty()||stack.peek()!=s.charAt(i)){//遍历s，如果和栈顶相同就弹出栈顶，不同就添加到栈，最后再翻转一下剩余的字符串
                stack.add(s.charAt(i));
            }
            else {
                stack.pop();
            }
        }
        while(!stack.isEmpty()){
            str.append(stack.pop());
        }
        return new String(str.reverse());

    }
}