java栈和队列

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量160 收藏 1
点赞数 2
分类专栏： java 数据结构 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51970219/article/details/121595457
版权

java栈和队列

1.栈(Stack)

1.1基本概念

1.栈：一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守先进后出 LIFO（Last IFirst Out）的原则。
2.压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
3.出栈：栈的删除操作叫做出栈。出数据在栈顶。

1.2栈的实现

1.栈的核心操作
pop():移除栈顶元素。
peek():查看栈顶元素单但不删除。
push():向栈中添加元素。

方法解释
E push(E item)压栈
E pop()出栈
E peek()查看栈顶元素
boolean empty()判断栈是否为空

2.栈的应用实例
(1)操作系统栈：方法调用过程-方法调用栈。
(2)浏览器的前进后退。
(3)编辑器的撤销crt+z(输入栈)。
(4)代码编辑器的括号匹配。
(5)算数运算的符号优先级匹配(双栈)
3.栈的底层实现有两种
(1)基于数组实现：顺序栈。
(2)基于链表实现：链式栈
4.在实际应用中当需要使用最近原则时用栈结构。
5.代码实现：
(1)Stack.java:

package stack_queue.stack;
import java.util.Arrays;
import java.util.NoSuchElementException;

public class Stack<E> {
    private E[] elementData;
    //当前栈中的实际元素个数
    private int size;
    public Stack() {
        elementData=(E[]) new Object[10];
    }
    public Stack(int initCap) {
        elementData = (E[]) new Object[initCap];
    }

    //入栈操作
    public void push(E value){
        elementData[size]=value;
        size++;
    }
    //出栈操作，返回原先的栈顶元素
    public E pop(){
        if (getSize() == 0) {
            // 当前栈为空
            throw new NoSuchElementException("栈为空!");
        }
        E oldValue=elementData[size-1];
        size--;
        elementData[size]=null;
        return oldValue;
    }
    //查看栈顶元素，不出栈
    public E peek(){
        if(getSize()==0){
            throw new NoSuchElementException("栈为空!");
        }
        return elementData[size-1];
    }

    private int getSize() {
        return size;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i <size ; i++) {
            sb.append(elementData[i]);
            if(i!=size-1){
                sb.append(",");
            }
        }
        sb.append("]top");
        return sb.toString();
    }
}

(2)StackTest.java:

package stack_queue.stack;
public class StackTest {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(3);
        stack.push(5);
        stack.push(7);
        // [1,3,5,7] top
        System.out.println(stack);
        // 7
        System.out.println(stack.peek());
        stack.pop();
        // [1,3,5] top
        System.out.println(stack);
    }
}

(3)
在这里插入图片描述

2. 队列(Queue)

2.1基本概念

1.队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out)
2.入队列：进行插入操作的一端称为队尾（Tail/Rear）
3.出队列：进行删除操作的一端称为队头 (Head/Front）。
在这里插入图片描述

2.2实现

1.队列的底层实现有两种：
(1)基于数组的队列;循环队列。
(2)基于链表的队列：由于队首元素删除时若采用数组实现每次出队后都需要进行数组元素的搬移工作，非常耗时效率会比较低。因此我们采用链表实现队列。
2.队列的核心操作:
(1)offer():向队列中添加元素。
(2)poll():移除队首元素 。
(3)peek():查看队首元素但不删除。

方法解释
E offer(E item)入队
E poll()出队
E peek()查看队首元素
boolean empty()判断队是否为空

3.代码实现：
(1)Queue.java(接口):

package stack_queue.queue;

public interface Queue {
    //入队操作
    void offer(int value);
    //出队操作
    int poll();
    //查看队首元素
    int peek();
}

(2)LinkedQueue.java:

package stack_queue.queue.impl;
import stack_queue.queue.Queue;
import java.util.NoSuchElementException;

// 基于链表的队列
// 队首出，队尾进
public class LinkedQueue implements Queue {
    private Node head;
    private Node tail;
    private int size;
    private class Node {
        private int data;
        private Node next;
        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 入队操作
     * @param value
     */
    @Override
    public void offer(int value) {
        //产生一个新元素
        Node node = new Node(value);
        if (head == null) {
            head = tail = node;
        }else {
            tail.next = node;
            tail = node;
        }
        size ++;
    }

    //出队
    @Override
    public int poll() {
        if (size == 0) {
            throw new NoSuchElementException("队列为空!");
        }
        int oldValue = head.data;
        Node tmpHead = head;
        head = head.next;
        tmpHead.next = null;
        size --;
        return oldValue;
    }

    //查看队首素，但不出队
    @Override
    public int peek() {
        if (size == 0) {
            throw new NoSuchElementException("队列为空!");
        }
        return head.data;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("front [");
        Node node = head;
        while (node != null) {
            sb.append(node.data);
            if (node.next != null) {
                sb.append(",");
            }
            node = node.next;
        }
        sb.append("] tail");
        return sb.toString();
    }
}

(3)QueueTest.java:

package stack_queue.queue;
import stack_queue.queue.impl.LinkedQueue;

public class QueueTest {
    public static void main(String[] args) {
        Queue queue=new LinkedQueue();
        queue.offer(1);
        queue.offer(3);
        queue.offer(5);
        queue.offer(7);
        //front[1,3,5,7]tail
        System.out.println(queue);
        queue.poll();
        //front[3,5,7]tail
        System.out.println(queue);
        System.out.println(queue.peek());
    }
}

(4)运行截图：
在这里插入图片描述

2.3循环队列

1.循环队列：
由于顺序队列每次在出队时，都会牵扯到数组头部的删除(O(1)),还要进行元素的搬移工作，非常耗时，效率比较低，因此我们采用循环队列。
2.循环队列实现的注意点：
(1)front指向循环队列的第一个元素索引。
(2)tail指向循环队列的最后一个元素的下一个位置arr[tail]=x;
(3)如何判断当前循环队列为空？

front==tail;

(4)如何判断当前循环队列为满？

(tail+1)%data.length==front;

(5)规定循环队列中浪费一个空间，这个空间不能存储元素(目的是判断队列满和空的区别)
在这里插入图片描述
此刻红色方框内不能存储元素。我们现在要存储的元素个数为K，数组就要开辟K+1个，要浪费一个空间。
队列满了以后：

size=data.length-1; 
(tail+1)%data.length==front;

(6)每次front和tail添加或者删除元素后向后移动：

(front+1)%data.length;
(tail+1)%data.length;

取模核心：当走到数组末尾时，继续从头开始入队和出队。
3.循环链表的代码实现以及运行截图：
(1)代码：
LoopQueue.java:

package stack_queue.queue.impl;
import stack_queue.queue.Queue;

public class LoopQueue implements Queue {
    private int[] data;
    //有效元素个数(仅用front和tail来计算有效元素个数)
    private int size;
    //指向队首元素下标
    private int front;
    //指向队尾元素的下一个位置下标
    private int tail;

    public LoopQueue(int k){
        data=new int[k+1];
    }

    @Override
    public void offer(int value) {
        //判断队列是否已满
        if(isFull()){
            //此时队列已满
            System.out.println("queue is full!");
            return;
        }
        data[tail]=value;
        tail=(tail+1)%data.length;
        size++;
    }

    @Override
    public int poll() {
        //判断队列是否为空
        if(isEmpty()){
            System.out.println("queue is empty!");
            return -1;
        }
        int value=data[front];
        front=(front+1)%data.length;
        size--;
        return value;
    }

    @Override
    public int peek() {
        if(isEmpty()){
            System.out.println("queue is empty!");
            return -1;
        }
        return data[front];
    }

    //如何查看队尾元素？
    public int getTail(){
        if(isEmpty()){
            System.out.println("queue is empty!");
            return -1;
        }
        //最后一个元素下标
        int index=tail==0?data.length-1:tail-1;
        return data[index];
    }

    public boolean isFull(){
        if((tail+1)%data.length==front) {
            return true;
        }
        return false;
    }

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

    public int getSize(){
        return size;
    }

    //遍历循环队列
    @Override
    public String toString(){
        StringBuilder sb=new StringBuilder();
        sb.append("front[");
        //取得最后一个元素索引
        int lastIndex=tail==0?data.length-1:tail-1;
        //遍历循环队列
        for (int i = front; i !=tail ;) {
            sb.append(data[i]);
            if(i !=lastIndex){
                sb.append(",");
            }
            i=(i+1)%data.length;
        }
        sb.append("]tail");
        return sb.toString();
    }

}

QueueTest.java:

package stack_queue.queue;
import stack_queue.queue.impl.LinkedQueue;
import stack_queue.queue.impl.LoopQueue;

public class QueueTest {
    public static void main(String[] args) {
        LoopQueue loopqueue=new LoopQueue(3);
        loopqueue.offer(1);
        loopqueue.offer(3);
        loopqueue.offer(5);
        loopqueue.offer(7);
        //front[1,3,5,7]tail
        System.out.println(loopqueue);
        loopqueue.poll();
        //[3,5,7]
        loopqueue.offer(9);
        //[3,5,7,9]
        System.out.println(loopqueue);
        //9
        System.out.println(loopqueue.getTail());
        //3
        System.out.println(loopqueue.peek());
    }
}

(2)运行截图：
在这里插入图片描述

3.双端队列

3.1基本概念

1.双端队列（deque）：是指允许两端都可以进行入队和出队操作的队列，那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

ZJHFOREVERZJ
关注
专栏目录
栈和队列的应用C++实验 （含代码 截图）
12-05
栈和队列的应用 包含流程图 源代码 截图 代码是老师给的，个为了方便操作和应用人稍加修改
Java——栈和队列
华墨1024的博客
11-08 350
本文将会对栈和队列，以及其使用Java如何实现做一个介绍，
数据结构学习2——栈和队列（通过C++代码例子）
m0_53552112的博客
07-31 771
本篇博客是通过c++实现栈和队列的两个实验小例子。判断回文数和停车场收费问题
栈和队列之顺序栈基础操作和效果图
Hello的博客
08-10 326
前言： 代码用C语言实现，有效果图和代码，代码可直接运行 共享栈和链栈代码就不写了 效果图： #include <stdio.h> #include <stdbool.h> #define MaxSize 150 typedef int ElemType; typedef struct{ ElemType data[MaxSize]; //存放栈中元素 int top; //栈顶指针 }SqStack; /*初始化栈*/ void Init
队列的应用、栈的应用
微信公众号: 后端码匠
12-06 1091
实验一：队列的应用、栈的应用 一． 实验目的 1、掌握队列的特点(先进先出 FIFO)及基本操作，如入队、出队等。 2、利用循环队列的特点解决实际问题，提高编程能力。 3、掌握栈的特点(先进后出 FILO)及基本操作，如入栈、出栈等。 4、利用栈的特点解决实际问题，提高编程能力。 二． 实验内容 1、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能： (1)初始化循环队列； (2)给定一个元素，将此元素插入此队列中； (3)将队头一个元素出队。 2、编程实现顺序栈的各种基本运
Java栈和队列
m0_74270127的博客
02-05 1884
什么是栈，Stack类讲解、模拟实现栈、区分栈、虚拟机栈、函数栈帧
java栈和队列的实现
qq_30136729的博客
11-16 1432
栈：后进先出 队列：先进先出 实现使用借助以下类实现： Stack：栈类 Queue：队列类 LinkedList：双端队列（栈操作建议使用） 一.栈的实现 栈的实现，有两个方法： 一个是用java本身的集合类型Stack类型；另一个是借用LinkedList来间接实现Stack。 Stack类 栈是Vector的一个子类，实现了一个标准的后进先出的栈，栈本身最重要的就是push和pop。 Stack<Integer> stack = new Stack<>(); St
Java栈和队列的实现
2301_80288511的博客
04-06 696
Java栈和队列的实现
Java实现栈和队列
小小太空人的博客
09-29 674
栈和队列是两种特有的存储数据的结构，栈是后进先出的一种结构，队列是先进先出的一种结构。由于这种特有的结构，在选择底层存储方式也有差异。由于栈是后进先出的结构，其实就是尾删，尾增操作，如果用顺序表来存储，尾删、尾增时间复杂度则是O（1）。链表则需考虑链表的结构，如果是单链表，找尾的时间复杂度就是O（n）。如果是记录尾的双向链表，时间复杂度是O（1）。Java中也封装了这样的集合结构（Stack），用的就是顺序表。由于队列是先进先出的结构，其实就是头删，尾增操作。
java栈和队列的区别是什么意思_java中的栈和队列有什么区别
weixin_33267354的博客
02-13 1250
java中的栈和队列有什么区别发布时间：2020-06-26 15:39:20来源：亿速云阅读：117作者：Leah今天就跟大家聊聊有关java中的栈和队列的区别，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。队列(Queue)：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表;栈(Stack)：是限定只能在表的一端进行插入和删除操...
Java实现栈和队列面试题
09-03
栈和队列是数据结构中的基础概念，它们在编程中有着广泛的应用，特别是在Java面试中常常被用来测试候选人的算法和数据结构理解能力。下面我们将详细探讨这些知识点。 1. **栈的创建**： 栈是一种后进先出（LIFO）...
java 栈和队列的小例子
03-29
在Java编程语言中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据存储和操作方面有着广泛的应用。本教程将通过一些小例子来深入理解这两种数据结构及其在Java中的实现。 栈是一种后进先出（LIFO...
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，它们在编程中有着广泛的应用。栈（Stack）遵循“后进先出”（Last In First Out, LIFO）原则，而队列（Queue）则遵循“先进先出”（First In First Out, FIFO）原则。 栈的...
Java 中的栈和队列
AlinaQ05的博客
08-06 2812
在顺序队列中，当下标走到队尾后，不能再往后走插入元素，但其实数组中还有位置，这叫做“假溢出”，为了解决这个问题提高数组利用率，就出现了循环队列。队列是一种仅支持在表尾进行插入操作、在表头进行删除操作的线性表，插入端称为队尾，删除端称为队首，因整体类似排队的队伍而得名。front：指向循环队列的第一个元素下标，rear：指向循环队列的最后一个元素的下一个下标。，元素入队即将新元素加在队列的尾，元素出队即将队首元素取出，它后一个作为新的队首。，使之成为新的栈顶元素；，使其相邻的元素成为新的栈顶元素。...
java栈和队列验证回文串_【数据结构】使用栈和队列判断字符串是否是回文
weixin_42515301的博客
02-24 1485
说明：这是武汉理工大学计算机学院计科专业【数据结构】课程的实验：使用栈和队列判断字符串是否是回文谨记：纸上得来终觉浅，绝知此事要躬行。原题目：假设称正读和反读都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’则不是回文。试写一个算法判别读入的一个以‘@’为结束符的字符序列是否是“回文”。源代码：// *.cpp: 定义控制台应用程序的入口点。#i...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 193
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 451
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 889
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 554
spring boot 整合 mybatis
java栈和队列判断回文
12-21
在Java中，可以使用栈和队列来判断一个字符串是否是回文。下面是一个示例代码： ```java import java.util.*; public class PalindromeChecker { public static boolean isPalindrome(String str) { // 创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZJHFOREVERZJ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值