JAVA学习记录（十六）—— 栈、队列

1、栈（Stack）

• 一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。遵循先进后出原则
  压栈：栈的插入操作叫做进栈/压栈/入栈
  出栈：栈的删除操作叫做出栈

集合中的栈操作

• stack.push() 在栈内放元素
• stack.pop() 拿到栈顶元素，但不删除
• stack.peek() 弹出栈顶元素
• stack.empty() 判断栈是否为空

public class TestDemo{
    public static void main(String[] args){
        Stack<Integer> stack = new Stack<>();
        stack.push(1); // 在栈里面放元素
        stack.push(2); 
        stakc.peek(); // 拿到栈顶元素，但不删除 
        stack.pop();  // 弹出栈顶元素
        stack.empty();  // 栈是否为空
        stack.isEmpty(); // 因为Stack是继承Voctor的，所以可以用这个方法
    }
}

• 如果栈已经为空了，再使用stack.empty()会抛出异常

自己实现一个Stack

public class MyStack{
    private int[] elem;
    private int top; //可以表示下标，也可以表示当前栈内有多少个元素
    
    public MyStack(){
        this.elem = new int[10]; // 这里默认给栈的大小为10
    }
    
    // 栈是否为空
    public boolean empty(){
         return this.top == 0;
    }
    
    // 判断栈是否满了
    public boolean isFull(){
        return this.top == this.elem.length;
    }
    
    // 栈的大小
    public int size(){
        return tis.top;
    }
    
    // 给栈内放元素（入栈）
    public int push(int item){
        if(isFull){
            throw new RuntimeException("栈为满");
        }
        this.elem[this.top] = item;
        this.top++;
        return this.elem[this.top - 1]; // top是栈顶元素的下一个下标位置
                                        // 要返回栈顶元素，所以要返回top - 1 位置                       
    }
    
    // 弹出栈顶元素 并删除
    public int pop(){
        if(empty()){ 
            throw new RuntimeException("栈为空");
        }
        this.top--;
        return this.elem(this.top);
    }
    
    // 拿到栈顶元素，不删除
    public int peek(){
	    if(empty()) {
	            //return -1;
	            throw new RuntimeException("栈为空");
	        }
	        return this.elem[this.top-1];
	    }
    }
}

• 习题、有效括号力扣（LeetCode）
  给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
  有效字符串需满足：
  左括号必须用相同类型的右括号闭合。
  左括号必须以正确的顺序闭合。
  注意空字符串可被认为是有效字符串。

示例 1:            示例 2:                示例 3:             示例 4:              示例 5:            
输入: "()"         输入: "()[]{}"         输入: "(]"          输入: "([)]"         输入: "{[]}" 
输出: true         输出: true             输出: false         输出: false          输出: true         

class Solution{
    public boolean isValid(String s){
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            if(ch == '(' || ch == '{' || ch == '{'){
                //说明当前遍历道德字符是左括号
                stack.push(ch);
            }else{
                // 1、判断当前的栈是否是空的
                if(stack.empty()){
                    return false; // 代表右括号多
                }
                // 2、拿到栈顶元素是否与当前字符匹配，如果匹配，当前栈顶元素出栈
                char topch = stack.peek();
                if(topch == '{' && ch == '}' || topch == '[' && ch == ']' || topch == '(' && ch == ')'){
                    stack.pop();
                }else{
                    return false; //左右括号不匹配
                }
            }
        }
        if(stack.empty()){
            return false; // 左括号多
        }
        return true;
    }
}

---

---

2、队列（Queue）

• 只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，具有先进先出。
• 入队列：进行插入操作的一端称为队尾（Tail/Rear）
• 出队列：进行删除操作的一端称为队头（Head/Front）

队列的实现

public class TestDemo{
    public static void main(String[] args){
        Queue<Integer> queue = new LinkList<>();
        // 底层是一个双向链表
        // 但Queue下只能实现单向链表的操作
        LinkedList<String> linkedList = new LinkList<>();
        //就可以实现双向链表
    }
}

以单链表来实现队列

class Node{
    public int val;
    public Node next;
    public Node(int val){
        this.val = val;
    }
}
public class MyQueue{
    public Node first; // 头
    public Node last;  // 尾
    
    // 入队
    public boolean offer(int val){
        Node node = new Node(val);
        if(this.first == null){
            this.first = node;
            this.last = node;
        }else{
            this.last.next = node;
            this.last = node;
        }
        return true;
    }
    // 出队
    public int poll() throw RuntimeException{
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        int ret = this.first.val;
        this.first = this.first.next;
        return ret;
        
    }
    // 得到队头元素不删除
    public int peek() throw RuntimeException{
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        return this.first.val;;
    }
    // 队列判空
    public boolean isEmpty(){
        if(this.last == null && this.first == null){
            return true;
        }
        return false;
    } 
}

数组实现队列（循环队列）

• rear 代表当前可以存放数据元素的下标，当front与rear相遇时，队列为空

• 问题：
  1、front和rear相遇，到底是空还是满？
  2、front与rear都有一个问题：front+1越界（一直出队列）；rear+1越界了

• 解决问题1：每次在放元素时，检查其下一个元素是否是front。如果是front，我们认为队列已满，即牺牲一个空间来判断满。

• 解决问题2：怎么让在判满的时候让rear下标+1等于0下标？
  判断 (rear+1) % len == front ？

public class MyCircularQueue{
    private int front;
    private int rear; // 代表当前可以存放数据元素的下标
    
    public MyCircularQueue(int k){
        this.elem = new int[k];
        this.front = 0;
        this.rear = 0;
    }
    
    // 入队
    public boolean enQueue(int value){
        if(isFull()){
            return false;
        }
        // 放到数组的rear下标
        this.elem[this.rear] = value;
        this.rear = (this.rear + 1) % this.elem.length;
        return true;
    }
    
    // 出队
    public boolean deQWueue(){
        if(isEmpty()){
            return false;
        }
        // 只需要挪动front下标
        this.front = (this.front + 1) % this.elem.length;
        return true;
    }
    
    // 得到队头元素
    public int Front(){
        // 只需要返回front元素的下标
        if(isEmpty()){
            return -1;
        }
        int ret = this.elem[this.front];
        return ret;
    } 
    
    // 得代队尾元素
    public int Rear(){
        if(isEmpty()){
            return -1;
        }
        int index = -1;
        if(this.rear == 0){
            index = this.elem.length - 1;
        }else{
            index = this.rear - 1;
        }
        return this.elem[index];
    }
    
    // 队列是否为空
    public boolean isEmpty(){
        return this.front == this.rear;
    }
    
    // 队列是否为满
    public boolean isFull(){
        return (this.rear + 1 ) % this.elem.length == this.front;
    }
}

用栈实现队列的基本操作

• 使用两个栈，一个栈用来存放入队的元素，因为队列是先进先出，所以在出队时，将入队中的n-1个元素出栈并依次入栈到另一个栈当中，此时

public class TwoStackQueue{
    private Stack<Integer> s1 = new Stack<>(); // 入队
    private Stack<Integer> s2 = new Stack<>(); // 出队
    public TwoStackQueue(){ }
    
    // 两队列判空
    public boolean empty(){
        return s1.empty() && s2.empty();
    }
    // 入队操作
    public void push(int x){
        s1.push(x);
    }

    // 出队操作
    public int pop(){
        if(empty()){ return -1;}
        if(s2.empty()){
            while(!s1.empty()){
                s2.push(s1.pop());
            }
            return s2.pop();
        }
        // 前面已经判断过s1和s2至少有一个不是空
        // 此时s1为空
        return s2.pop();
    }
    
    // 得到出队元素
    public int peek() {
        if(empty()) {
            return -1;
        }
        if(s2.empty()) {
            while(!s1.empty()) {
                s2.push(s1.pop());
            }
        }
        if(s2.empty()) {
            return -1;
        }
        //s2
        return s2.peek();        
    }
}

用队列实现栈

• 使用两个队列实现栈操作，入栈时进入其中一个队列中，当执行出栈操作时，由于栈要求先进后出，而队列是先进先出，所以，将第一个队列中的n-1个元素依次出队到第二个队列中，此时第一个队列剩下的一个元素就是此队列原本的对尾了，此时使用队列出队的方法队第一个队列执行出队操作poll()。

public MyStack{
    private Queue<Integer> qu1 = new LinkedList<>();
    private Queue<Integer> qu2 = new LinkedList<>();
    
    public MyStcak(){ }
    
    // 入栈
    public void push(int x){
        // 那个队列不为空，入栈就进入那个队列
        // 当两个队列都为空时，默认进入q1队列
        if(!qu1.isEmpty()){ 
            qu1.offer(x);
        }else if(!qu2.isEmpty){
            qu2.offer(x);
        }else{
            qu1.offer(x); 
        }
    }
    // 判断栈空
    public boolean empty(){
        return qu1.isEmpty() && qu2.isEmpty();
    }
    
    // 出栈
    public int pop(){
        if(empty()){
            return -1;
        }
        // 每次出不为空的队列，出size-1个，到另一个空的队列，然后弹出剩余的哪一个元素
        if(!qu1.isEmpty()){
            int size = qu1.size();
            for(int i = 0; i < size - 1; i++){
                qu2.offer(qu1.poll());
            }
            return qu1.poll();
        }else{
            int size = qu2.size();
            for(int i = 0; i < size - 1; i ++){
                qu1.offer(qu2.poll());
            }
            return qu2.poll();
        }
    }
    
    // 拿到栈顶元素
    public int top(){
        if(empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size = qu1.size();
            int cur = -1;
            for(int i = 0; i < size; i++){
                cur = qu1.poll();
                qu2.offer(cur);
            }
            return cur;
        }else{
            int size = qu2.size();
            int cur = -1;
            for(int i = 0; i < size; i++){
                cur = qu2.poll();
                qu1.offer(cur);
            }
            return cur;
        }
    }
}

实现最小栈：在常数时间内检索到最小元素的栈

public class MinStck{
    private Stack<Integer> stack = new Stack<>();
    private Stack<Integer> minStack = new Stack<>();
    
    public MinStack(){ }
        
    // 入栈
    public void push(int x){
        stack.push(x);
        if(minStack.isEmpty()){
            minStack.push(x);
        }else{
            if(x < minStack.peek(){ // 只在最小栈中放入最小元素
                minStack.push(x);
            }
        }
    }
    
    // 出栈
    public void pop(){
        if(stack.peek().equals(minStack.peek())){
            stack.pop();
            minStack.pop();
        }else{
            stack.pop();
        }
    }
    
    // 拿到栈顶，这个与最小栈没有关系
    public int top(){
        return stack.peek();
    }
    
    // 拿到栈中的最小元素
    public int getMin(){
        return minStack.peek();
    }
}