【Java】Stack和Queue的使用

最新推荐文章于 2024-05-20 10:33:35 发布
最新推荐文章于 2024-05-20 10:33:35 发布
阅读量322 收藏 1
点赞数 2
分类专栏： Java基础 文章标签： java 栈和队列 stack queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61635026/article/details/131577719
版权

文章目录

一、栈

1.1 什么是栈

栈（Stack）是一种常见的数据结构，它遵循"后进先出"（Last-In-First-Out，LIFO）的原则。在栈中，最后添加的元素首先被访问或删除，而最先添加的元素则最后被访问或删除。

栈具有以下特点：

  1. 插入操作称为"入栈"（push）：将元素添加到栈的顶部。
  2. 删除操作称为"出栈"（pop）：从栈的顶部移除元素。
  3. 只能访问栈顶的元素：栈是一种限制性访问的数据结构，只允许访问或操作栈顶的元素。
  4. 栈的大小是动态的：栈的大小可以根据需要自动增长或缩小。

1.2 栈的模拟实现

import java.util.Arrays;

public class MyStack {
    private int[] elem;
    private int usedSize;

    public static final int DEFAULT_SIZE = 10;

    public MyStack(){
        elem = new int[DEFAULT_SIZE];
    }

    public void push(int val){
        // 如果栈满了就扩容
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem, 2 * Arrays.stream(this.elem).sum());
        }

        this.elem[usedSize] = val;
        usedSize++;
    }

    private boolean isFull(){
        return usedSize == elem.length;
    }

    private boolean isEmpty(){
        return usedSize == 0;
    }

    public int pop(){
        if(usedSize == 0){
            throw new MyEmptyException("栈已经空！");
        }
        return elem[--usedSize];
    }

    public int size(){
        return usedSize;
    }

    public int peek(){
        if (isEmpty()){
            throw new MyEmptyException("栈已经空！");
        }
        return elem[usedSize - 1];
    }
}

二、Java中的Stack

在Java中，Stack类是一个继承自Vector类的类，它实现了一个后进先出（LIFO）的堆栈数据结构。Stack类提供了一些方法来实现栈的常见操作，例如压栈（push）、弹栈（pop）、查看栈顶元素（peek）等。

Stack的继承体系如图：

2.1 构造方法

在Java中，Stack类提供了以下几个构造方法：

  1. Stack()：创建一个空的Stack对象。
Stack<String> stack = new Stack<>();
  1. Stack(Collection<? extends E> c)：创建一个包含指定集合中的元素的Stack对象。集合中的元素将按照迭代器返回的顺序添加到Stack中。
List<String> collection = new ArrayList<>();
collection.add("Element 1");
collection.add("Element 2");
Stack<String> stack = new Stack<>(collection);

另外，需要注意的是，Stack类在Java 1.0中引入，但自Java 1.6起，官方推荐使用更加通用的Deque接口（如ArrayDeque或LinkedList）来代替Stack类，因为Deque提供了更丰富的操作方法，并且更加高效。

2.2 操作方法

Stack类提供了一些常见的操作方法，可以用于实现栈的功能。以下是一些常用的Stack操作方法：

  1. push(E item)：将元素item压入栈顶。
Stack<String> stack = new Stack<>();
stack.push("Element 1");
stack.push("Element 2");
  1. pop()：弹出并返回栈顶的元素。
Stack<String> stack = new Stack<>();
stack.push("Element 1");
stack.push("Element 2");
String topElement = stack.pop(); // 返回"Element 2"，栈顶的元素被弹出
  1. peek()：返回栈顶的元素，但不对栈进行修改。
Stack<String> stack = new Stack<>();
stack.push("Element 1");
stack.push("Element 2");
String topElement = stack.peek(); // 返回"Element 2"，栈顶的元素不会被弹出
  1. empty()：检查栈是否为空。
Stack<String> stack = new Stack<>();
boolean isEmpty = stack.empty(); // 返回true，栈为空
  1. search(Object o)：查找元素o在栈中的位置，返回距离栈顶的距离（栈顶元素的位置为1，依次递增）。
Stack<String> stack = new Stack<>();
stack.push("Element 1");
stack.push("Element 2");
int position = stack.search("Element 1"); // 返回2，"Element 1"距离栈顶的位置为2

除了上述方法外，Stack类还继承了Vector类的其他方法，例如size()、isEmpty()、clear()等。

另外，由于Stack类是线程安全的，使用同步方法来实现的，而在Java的并发编程中，建议使用更高效的并发类（如ConcurrentLinkedDeque）代替Stack类。

2.3 应用场景

  1. 括号匹配问题
class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();

        for (char ch : s.toCharArray()) {
            if(ch == '('){
                stack.push(')');
            } else if (ch == '{') {
                stack.push('}');
            } else if (ch == '[') {
                stack.push(']');
            } else if(stack.isEmpty() || ch != stack.pop()) {
                return false;
            }
        }

        return stack.isEmpty();
    }
}
  1. 逆波兰表达式求值
class Solution {
    
    // tokens = ["2","1","+","3","*"] 9
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();

        for (String str : tokens) {
            switch (str) {
                case "+" -> {
                    int right = stack.pop();
                    int left = stack.pop();
                    stack.push(left + right);
                }
                case "-" -> {
                    int right = stack.pop();
                    int left = stack.pop();
                    stack.push(left - right);
                }
                case "*" -> {
                    int right = stack.pop();
                    int left = stack.pop();
                    stack.push(left * right);
                }
                case "/" -> {
                    int right = stack.pop();
                    int left = stack.pop();
                    stack.push(left / right);
                }
                default -> {
                    Integer integer = Integer.valueOf(str);
                    stack.push(integer);
                }
            }
        }
        return stack.pop();
    }
}

三、队列

3.1 什么是队列

队列（Queue）是一种常见的数据结构，它遵循"先进先出"（First-In-First-Out，FIFO）的原则。在队列中，最先添加的元素首先被访问或删除，而最后添加的元素则最后被访问或删除。

队列具有以下特点：

  1. 插入操作称为"入队"（enqueue）：将元素添加到队列的末尾。
  2. 删除操作称为"出队"（dequeue）：从队列的头部移除元素。
  3. 只能访问队列头部和尾部的元素：队列是一种限制性访问的数据结构，只允许访问或操作队列的头部和尾部元素。
  4. 队列的大小是动态的：队列的大小可以根据需要自动增长或缩小。

3.2 队列的模拟实现

public class MyQueue {
    static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    private ListNode head; // 队头出
    private ListNode tail; // 队尾入

    public void offer(int val) {
        if (head == null){
            head = new ListNode(val);
            tail = head;
        } else {
            ListNode node = new ListNode(val);
            tail.next = node;
            tail = node;
        }
    }

    public int poll() {

        if(isEmpty()){
            throw new MyEmptyException("队列为空！");
        }

        int tmp = head.val;
        head = head.next;
        if (head == null)
            tail = null;
        return tmp;
    }

    public int peek() {
        if(isEmpty()){
            throw new MyEmptyException("队列为空！");
        }
        return head.val;
    }

    public int size() {
        if(isEmpty()){
            return 0;
        }

        int cnt = 0;
        ListNode cur = head;
        while (cur != null){
            cnt++;
            cur = cur.next;
        }
        return cnt;
    }

    public boolean isEmpty() {
        return head == null;
    }

    public void display(){
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}

四、Java中的Queue

在Java中，Queue是一个接口，它表示一种先进先出（FIFO）的队列数据结构。它是Java集合框架的一部分，定义了一些方法来操作队列。Queue接口的常见实现类包括LinkedList和ArrayDeque。其继承体系如下：

4.1 实例化方法

Queue接口本身是一个接口，不能直接实例化。在Java中，我们可以使用具体的实现类来创建Queue对象，常用的实现类有LinkedList和ArrayDeque。

  1. LinkedList实现的Queue：
Queue<String> queue = new LinkedList<>();
  1. ArrayDeque实现的Queue：
Queue<String> queue = new ArrayDeque<>();

这些构造方法创建了一个空的Queue对象，可以根据需要将元素添加到队列中。

4.2 操作方法

Queue接口提供了一系列方法来操作队列。以下是Queue接口的一些常见操作方法：

  1. add(E e)：将元素e插入队列的尾部，如果成功则返回true，如果队列已满则抛出异常。
Queue<String> queue = new LinkedList<>();
boolean result = queue.add("Element 1");
  1. offer(E e)：将元素e插入队列的尾部，如果成功则返回true，如果队列已满则返回false。
Queue<String> queue = new LinkedList<>();
boolean result = queue.offer("Element 1");
  1. remove()：移除并返回队列头部的元素，如果队列为空则抛出异常。
Queue<String> queue = new LinkedList<>();
String element = queue.remove();
  1. poll()：移除并返回队列头部的元素，如果队列为空则返回null。
Queue<String> queue = new LinkedList<>();
String element = queue.poll();
  1. element()：返回队列头部的元素，如果队列为空则抛出异常。
Queue<String> queue = new LinkedList<>();
String element = queue.element();
  1. peek()：返回队列头部的元素，如果队列为空则返回null。
Queue<String> queue = new LinkedList<>();
String element = queue.peek();

此外，Queue接口还继承了Collection接口和Iterable接口中的方法，例如size()、isEmpty()、clear()、iterator()等。

4.3 应用场景

  1. 队列实现栈
// 两个队列
// 入栈：入到不为空的队列
// 出栈：找到不为空的队列，出size - 1个元素到空队列，返回最后一个元素

// 使用队列实现栈
class MyStack {
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        // 两个队列都为空的时候
        if(empty()){
            queue1.offer(x);
            return;
        }


        if(queue1.isEmpty()){
            queue2.offer(x);
        } else {
            queue1.offer(x);
        }
    }
    
    public int pop() {
        if(empty()){
            return -1;
        }

        if(queue1.isEmpty()){
            int size = queue2.size();
            while (size - 1 != 0){
                queue1.offer(queue2.poll());
                size--;
            }
            return queue2.poll();
        } else {
            int size = queue1.size();
            while (size - 1 != 0){
                queue2.offer(queue1.poll());
                size--;
            }
            return queue1.poll();
        }
    }
    
    public int top() {
        int tmp = pop();
        push(tmp);
        return tmp;
    }
    
    public boolean empty() {
        return queue1.isEmpty() && queue2.isEmpty();
    }
}
  1. 栈实现队列
class MyQueue {

    private Stack<Integer> inStack; // 入栈
    private Stack<Integer> outStack; // 出栈

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();

    }
    
    public void push(int x) {
        inStack.push(x);
    }
    
    public int pop() {
        if (empty()){
            return -1;
        }

        if (outStack.isEmpty()) {
            while (!inStack.empty()) {
                outStack.push(inStack.pop());
            }
        }
        return outStack.pop();
    }
    
    public int peek() {
        if(outStack.empty()){
            while (!inStack.empty()){
                outStack.push(inStack.pop());
            }
        }

        return outStack.peek();
    }
    
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }
}
求知.
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java笔记之Deque与Stack
来自蒟蒻LebronGod的博客
03-17 5988
使用Deque 允许两头都进，两头都出，这种队列叫双端队列（Double Ended Queue），简称Deque。 Java集合提供了接口Deque来实现一个双端队列，它的功能： ①既可以添加到队尾，也可以添加到队首； ②既可以从队首获取，又可以从队尾获取。 在原来的queue的方法名上加了表示在队首还是队尾操作的表示（Last或First）。 Deque接口实际上扩展自Queue： publ...
Java_Stack_Queue:Java中使用链表的堆栈和队列实现
07-03
在Java编程语言中，堆栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据存储和操作时扮演着重要角色。本文将深入探讨如何使用链表（LinkedList）来实现这两种数据结构。 首先，让我们了解堆栈和队列...
Java Stack使用
dihan0379的博客
02-27 125
1、Stack继承自Vector。遵从先进后出的规则。 2、Stack 是线程同步的。(map、List、Set是线程不同步的，需要在外部封装的时候来同步) 试例代码： public static void main(String[] args) {// TODO 自动生成的方法存根 //stack 继承自vector,遵循先进后出的原则Stack&l...
Java中的堆栈（Stack）技术详解
最新发布
m0_61431263的博客
05-20 388
Java中的堆栈（Stack）技术详解在Java编程中，堆栈（Stack）是一种重要的数据结构，它遵循后进先出（LIFO，Last In First Out）的原则，即最后一个入栈的元素总是第一个出栈。Java标准库并没有直接提供一个名为“Stack”的类，但我们可以使用类或者更常用的接口（如ArrayDeque或LinkedList）来实现堆栈的功能。由于类被认为是遗留类，因此在现代编程中更推荐使用Deque接口的实现类。
Java Stack用法
Donald_Draper
10-13 141
java.util.Stack类简介 ：[url]http://blog.csdn.net/a19881029/article/details/9408649[/url] Stack是一个后进先出（last in first out，LIFO）的堆栈，在Vector类的基础上扩展5个方法而来 Deque（双端队列）比起Stack具有更好的完整性和一致性，应该被优先使用,Stack本身通过扩展V...
java中的Stack的使用
哆啦A梦的博客
06-21 1070
JAVA 中，使用 java.util.Stack 类的构造方法创建对象。 public class Stack extends vector 构造方法 ： public Stack() 创建一个空 Stack。 方法： . public push （item ） 把项 压入栈顶。其作用与 addElement (item ) 相同。 参数 item 压入栈顶的项 。 返回： i
Java栈Stack的使用
jakelihua
10-05 411
简介：栈是在现实工程项目中和算法比赛中最常用的数据结构之一，Java内置Stack数据结构，本文旨在用最简洁和快速的方式教会大家使用Stack。
Lists_Stack_Queue_PriorityQueue.java
03-22
在Java编程语言中，`Lists`, `Stack`, `Queue`, 和 `PriorityQueue` 是四个重要的数据结构，它们各自在不同的场景下发挥着关键作用。这些数据结构是Java集合框架的一部分，帮助开发者有效地组织和操作数据。 1. **...
stack_queue
02-26
在IT行业中，数据结构是编程基础的重要组成部分，而栈（Stack）和队列（Queue）是两种最基本且广泛使用的数据结构。在这个名为"stack_queue"的项目中，我们可以推测它可能是一个关于Java实现栈和队列操作的学习资源...
stack_queue_p2pchat_practice:只是使用Stack和Queue技术的Java实践聊天应用程序
03-14
4. **并发控制**：如果应用支持多线程，需要确保Stack和Queue的线程安全，可以使用Java的synchronized关键字或Lock接口。 5. **界面交互**：提供图形用户界面（GUI）或者命令行界面（CLI），让用户能够方便地输入和...
Java ArrayDeque实现Stack的功能
09-02
`ArrayDeque` 在 Java 6 中被引入，并且它实现了 `Deque` 接口，同时也实现了 `Queue` 接口的部分方法。与 `Stack` 类不同，`ArrayDeque` 不提供线程安全的操作，因此在多线程环境中需要额外的同步措施。 `...
【Java基础/数据结构】栈（Stack）与队列（Queue、Deque）
Sun_study的博客
01-27 277
Java堆栈、队列
[Java]Stack类的使用
qq_61925446的博客
05-03 857
值得一提的是，List和Collection接口中都定义的isEmpty()方法来判断栈是否为空，栈使用的是empty()方法；Stack的底层存储结构是数组，Stack的进出方式是后进先出，Stack实现了List接口。Stack的常用方法都具有Stack的特色。（4）获取栈内元素个数和判断栈是否为空。Stack只有无参构造一种构造方法。二、Stack的常用方法。一、Stack的创建。（3） 获取栈顶元素。三、Stack的应用。（1）将递归变为循环。
java中stack的使用方法
yups
04-04 3493
java中stack的使用方法，堆栈是一种"后进先出"（LIFO）的数据结构，只能在一端进行插入（称为"压栈"）或删除（称为"出栈"）数据的操作. JAVA 中，使用 java.util.Stack 类的构造方法创建对象。 public class Stack extends vector 构造方法 ： public Stack() 创建一个空 Stack。 方法： public push（item ） 把项 压入栈顶。其作用与 addElement (item ) 相同。 参数 item 压入栈顶的
Java中Stack的用法
BABM的博客
08-25 1762
在做题的时候发现，Java帮我们实现了栈数据结构的一个类，并封装了起来，为Stack类 那么栈数据结构的用法师先进后出，后进先出，下面给一个图说明: Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆
Java Stack的简单用法
number_cmd9的博客
09-25 790
Java Stack 的简单用法 stack（栈）是数据结构中很重要的成员，在实际运用中其实也有很大左右，包括Android中的FragmentManager就是通过栈来管理fragment页面，如果去看栈的源码的话其实很容易发现Stack是通过数组来实现的。 原理简述 虽然这篇文章的核心是说如何对Stack进行使用，但适当的了解Stack的原理会对使用更有帮助，Stack栈的一大特点就是先进后出，如图进入栈的顺序依次是一号选手，二号选手和三号选手，但出来的顺序却是三号选手，二号选手和一号选手，这是栈这个结
Deque实现Stack
code_java_zqy
02-07 1395
Stack只有入栈和出栈的操作： 把元素压栈：push(E)； 把栈顶的元素“弹出”：pop(E)； 取栈顶元素但不弹出：peek(E)。 在Java中，我们用Deque可以实现Stack的功能： 把元素压栈：push(E)/addFirst(E)； 把栈顶的元素“弹出”：pop(E)/removeFirst()； 取栈顶元素但不弹出：peek(E)/peekFirst()。 为什么Java的集合类没有单独的Stack接口呢？因为有个遗留类名字就叫Stack，出于兼容性考虑，所以没办法创建Stack接
Java Stack的正确使用方式
xharvard的专栏
12-30 281
官方已经不推荐使用 new Stack()来实现栈了。Deque是指双端队列，当然也满足栈的单端出入形式。
Java中Stack类的用法
u013111776的博客
03-19 1834
java中stack的使用方法，堆栈是一种"后进先出"（LIFO） 的数据结构， 只能在一端进行插入（称为"压栈"） 或删除 （称为"出栈"）数据的操作,下面看示例吧 JAVA 中，使用 java.util.Stack 类的构造方法创建对象。  public class Stack extends vector  构造方法 ： public Stack() 创建一个空 Sta
java中用stack和queue判断回文
06-01
同样可以使用栈和队列来判断一个字符串是否为回文，下面是Java实现的代码示例： ```java import java.util.Stack; import java.util.LinkedList; public class PalindromeChecker { public static boolean ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

求知.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值