栈与队列之练习基础篇

栈与队列之练习基础篇

1.剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead","deleteHead"]
[[],[3],[],[],[]]
输出：[null,null,3,-1,-1]
//null表示无返回值

解题思路：

1>.队列的特点是先进先出，两个栈，一个用于入队操作，一个用于出队操作

2>.入队时直接将元素加入到第一个栈中

3>.出队首先判断第二个栈是否为空，为空，则将第一个栈中元素弹出，并压入第二个栈中；不为空，直接从第二个栈中弹出元素

4>.由于栈特点与队列不同，是先进后出，因此需要将元素先压入第一个栈，再弹出，压入第二个栈，这样就实现了队列先进先出的结构

class CQueue {
    //定义两个栈 
    Stack<Integer> stack1;
    Stack<Integer> stack2;

    //初始化栈
    public CQueue() {
        this.stack1 = new Stack<>();
        this.stack2 = new Stack<>();
    }

    //队尾入操作
    public void appendTail(int value) {
        //将元素先压入栈1中
        stack1.push(value);
    }

    //队首出操作
    public int deleteHead() {
        //注意要判断栈是否为空
        if (stack1.isEmpty() && stack2.isEmpty()) {
            return -1;
        }
        else{
            //栈2中若有元素，先弹出栈2中的元素
            if(stack2.isEmpty()){
                //栈2中没有元素，将栈1中后入队的元素压入栈2中
                while(!stack1.isEmpty()){
                    stack2.push(stack1.pop());
                }
            }
            //队首弹出元素
            return stack2.pop();
        }
    }
}

2.用栈实现队列(leetcode 232)

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾

int pop() 从队列的开头移除并返回元素

int peek() 返回队列开头的元素

boolean empty() 如果队列为空，返回 true ；否则，返回 false

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

class MyQueue {

    Stack<Integer> in;
    Stack<Integer> out;

    public MyQueue() {
        in=new Stack<>();
        out=new Stack<>();
    }

    public void push(int x) {
        in.push(x);
    }
    
//注意：对于出队操作和返回队首元素操作，必须判断栈是否为空
    
    public int pop() {
        if(empty()){  //两个栈都为空,抛出异常
            throw new IllegalArgumentException("stack is empty!");
        }
        else{
            //判断用于出队的栈是否为空
            if(out.isEmpty()){  
                //出队操作的栈为空，将进行入队操作的栈中的元素压入出队栈中
                while(!in.isEmpty()){
                    out.push(in.pop());
                }
            }
            //出队栈不为空，直接弹出栈顶元素(队首出)
            return out.pop();
        }
    }

    public int peek() {
        //调用empty()方法判断，两个栈都为空
        if(empty()){  
            throw new IllegalArgumentException("stack is empty!");
        }
        else{
            判断用于出队的栈是否为空
            if(out.isEmpty()){  
                while(!in.isEmpty()){
                    out.push(in.pop());
                }
            }
            //返回栈顶元素(返回队首元素操作)
            return out.peek();
        }
    }

    public boolean empty() {
        //两个栈都为空，返回true,否则返回false
        return in.isEmpty() && out.isEmpty();
    }
}

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

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

解题思路：

1>.首先分析题意，删除两个相邻且相同的字母，使用栈来解决此问题

2>.先判断栈是否为空，空，直接将元素压入栈中，不为空，将此元素与栈顶元素(即相邻两个元素)进行匹配，相同弹出栈顶元素，否则，此元素入栈

3>.循环，直到给定字符串遍历结束

4>.遍历栈中元素，将元素存入可变字符串StringBulider中并返回

class Solution {
    Stack<String> stack=new Stack<>();
    public String removeDuplicates(String s) {
        for(int i=0;i<s.length();i++){
            //valueOf():将字符转为字符串，charAt(i):返回字符串中的i位置的字符
            String str=String.valueOf(s.charAt(i));
            //在匹配之前先判断栈是否为空，空直接进栈
            if(stack.isEmpty()){
                stack.push(str);
            }
            else{
                //不为空，该元素与栈顶元素进行匹配
                if(stack.peek().equals(str)){
                    //栈顶元素与匹配元素相等，弹出
                    stack.pop();
                }
                else{
                    //不相等，匹配元素入栈
                    stack.push(str);
                }
            }
        }
        //可变长度字符串，存放栈中元素
        StringBuffer sb=new StringBuffer();
        //一般使用while循环遍历栈
        while(!stack.isEmpty()){
            String string=stack.pop();
            sb.append(string);
        }
        //将字符串进行反转
        sb.reverse();
        return sb.toString();
    }
}