栈与队列基础巩固之刷题篇

最新推荐文章于 2024-10-17 11:21:39 发布

燃星cro

最新推荐文章于 2024-10-17 11:21:39 发布

阅读量434

点赞数 8

文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/2302_79900935/article/details/140770957

版权

栈

栈的通俗解释：

在从上往下堆积木时候，只能从最顶部放置积木，或者从最顶部拿走基本。积木最顶端叫做栈顶，积木最底端叫做栈底。从下往上堆积木的过程叫做堆栈或者压栈，从上往下拿走积木的过程叫做出栈。

栈Stack（先进后出）

push() //入栈

pop() //将栈顶元素出栈

peek() //获取栈顶元素

size() //获取栈中元素个数

empty() //检测栈是否为空

可用顺序表和链表来存储栈，栈可以依照存储结构分为两种；顺序栈和链式栈。在栈的定义中已经说明，栈是一种在操作上稍加限制的线性表，即栈本质上是线性表，而线性表有两种主要的存储结构—— 顺序表和链表，因此栈也同样有对应的两种存储结构。

例题：

1.155. 最小栈 - 力扣（LeetCode）

class MinStack {
    private Stack<Integer> a;
    private Stack<Integer> b;
    public MinStack() {
        a=new Stack<>();
        b=new Stack<>();
    }

    public void push(int val) {
        a.add(val);
        if(b.isEmpty()||b.peek()>=val){
            b.add(val);
        }
    }

    public void pop() {
        if(!a.isEmpty()){
            int z=a.pop();
            if(z==b.peek())
                b.pop();
        }
    }

    public int top() {
        if(!a.isEmpty()){
            int z=a.peek();
            return z;
        }else
        return -1;
    }

    public int getMin() {
        if(!b.isEmpty()) {
            return b.peek();
        }else
        return -1;
    }
}

2.20. 有效的括号 - 力扣（LeetCode）

class Solution {
    public boolean isValid(String s) {
        Stack a=new Stack<>();
        for(int i=0;i<s.length();i++){
            if(a.isEmpty()){
                a.add(s.charAt(i));
            }else{
                char k=(char)a.peek();
                if((k=='('&&s.charAt(i)==')')||(k=='{'&&s.charAt(i)=='}')||(k=='['&&s.charAt(i)==']'))
                    a.pop();
                else{
                    a.add(s.charAt(i));
                }
            }
        }
        if(a.isEmpty())
            return true;
        else 
            return false;
    }
}

3.栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com)

import java.util.*;
public class Solution {
        public boolean IsPopOrder(int[] pushV, int[] popV) {
        int a = pushV.length;
        int b = popV.length;
        int z = 0;
        Stack<Integer> k = new Stack<Integer>();
        for (int i = 0; i < a; i++) {
            k.add(pushV[i]);
            while (!k.isEmpty() && popV[z] == (int) k.peek()) {
                k.pop();
                z++;
            }
        }
        if (k.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }
}

4.150. 逆波兰表达式求值 - 力扣（LeetCode）

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> k=new Stack<Integer>();
        for (int i = 0; i < tokens.length; i++) {
            if(tokens[i].equals("+")||tokens[i].equals("-")||tokens[i].equals("*")||tokens[i].equals("/")){
                int a=k.pop();
                int b=k.pop();
                switch (tokens[i]){
                    case "+":
                        k.add(b+a);
                        break;
                    case "-":
                        k.add(b-a);
                        break;
                    case "*":
                        k.add(b*a);
                        break;
                    case "/":
                        k.add(b/a);
                        break;
                }
            }else {
                k.add(Integer.parseInt(tokens[i]));
            }
        }
        return k.pop();
    }
}

队列

通俗的解释：

在人们排队买东西时候，都是先到收银台的顾客先出超市，只有等排在前面的顾客结完账之后，后面的顾客才能结账。也就是所谓的先进先出。

队列Queue（先进先出）

offer() //入队

poll() //出队

peek() //获取队头元素但是不删除

可用顺序队和链队来存储队列，队列可以依照存储结构分为两种；顺序栈和链式栈。在队列的定义中已经说明，队列是一种在操作上稍加限制的线性表，即栈本质上是线性表，而线性表有两种主要的存储结构—— 顺序表和链表，因此队列也同样有对应的两种存储结构。顺序队又有普通队列和循环队列，是根据队列的特定从普通队列转化形成的循环队列，用于节省存储空间。

例题：

1.225. 用队列实现栈 - 力扣（LeetCode）

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

    public void push(int x) {
        queue2.add(x);
        while(!queue1.isEmpty()){
            queue2.add(queue1.poll());
        }
        Queue<Integer> k=new LinkedList<Integer>();
        k=queue1;
        queue1=queue2;
        queue2=k;
    }

    public int pop() {
        if(!queue1.isEmpty())
            return queue1.poll();
        else 
            return -1;
    }

    public int top() {
        if(!queue1.isEmpty())
            return queue1.peek();
        else 
            return -1;
    }

    public boolean empty() {
        if(queue1.isEmpty())
            return true;
        else
            return false;
    }
}

2.232. 用栈实现队列 - 力扣（LeetCode）

class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public MyQueue() {
        stack1=new Stack<Integer>();
        stack2=new Stack<Integer>();
    }

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

    public int pop() {
        if(stack1.isEmpty()){
            while(!stack2.isEmpty()){
                stack1.add(stack2.pop());
            }
        }
        return stack1.pop();
    }

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

    public boolean empty() {
        return stack1.isEmpty()&&stack2.isEmpty();
    }
}

3.622. 设计循环队列 - 力扣（LeetCode）

class MyCircularQueue {
    private int[] elem;
    private int front;
    private int last;
    private int use;
    public MyCircularQueue(int k) {
        use=k+1;
        elem=new int[use];
        front=0;
        last=0;
    }

    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }
        elem[last]=value;
        last=(last+1)%use;
        return true;
    }

    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        front=(front+1)%use;
        return true;
    }

    public int Front() {
        if (isEmpty()){
            return -1;
        }else {
            return elem[front];
        }
    }

    public int Rear() {
        if (isEmpty()){
            return -1;
        }else {
            return elem[(last-1+use)%use];
        }
    }

    public boolean isEmpty() {
        return last==front;
    }

    public boolean isFull() {
        return ((last+1)%use)==front;
    }
}