JAVA学习日记(12)——栈和队列

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

1.栈(Stack)

1.1 概念

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

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据在栈顶。

在这里插入图片描述
在这里插入图片描述

1.2 方法

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

代码示例

public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(12);
        stack.push(13);
        stack.push(14);
        stack.push(15);
        System.out.println(stack);
        System.out.println("size = " + stack.size());
        int ret = stack.pop();
        System.out.println(stack.peek());
        System.out.println(ret);
        System.out.println(stack);
        System.out.println("size = " + stack.size());
    }

运行结果

[12, 13, 14, 15]
size = 4
14
15
[12, 13, 14]
size = 3

1.3 实现

  1. 利用顺序表实现，即使用尾插 + 尾删的方式实现
  2. 利用链表实现，则头尾皆可

相对来说，顺序表的实现上要更为简单一些，所以我们优先用顺序表实现栈。

代码示例

//顺序栈
class MyStack {
    public int[] elem;
    public int top;

    public MyStack() {
        this.elem = new int[10];
    }

    public void push(int item) {
    	//这里不考虑扩容
        if (isFull()) {
            System.out.println("溢出");
            return;
        }
        this.elem[top++] = item;
    }

    public int pop() {
        if (empty()) {
            throw new RuntimeException("栈为空");
        }
        int ret = this.elem[top-1];
        this.top--;
        return ret;
    }

    public int peek() {
        if (empty()) {
            return -1;
        }
        return this.elem[top-1];
    }

    public boolean empty() {
        if (top == 0) {
            return true;
        }else {
            return false;
        }
    }

    public boolean isFull() {
        if (top == elem.length) {
            return true;
        }else {
            return false;
        }
    }
}
public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        myStack.push(4);
        //System.out.println(myStack.pop());
        System.out.println(myStack.peek());
        System.out.println(myStack.pop());
        System.out.println(myStack.peek());
}

运行结果

4
4
3

如果要使用泛型，我们只需要添加上<>，把相应的类型变成泛型即可

代码示例

//顺序栈
class MyStack<T> {
    public T[] elem;
    public int top;

    public MyStack() {
        this.elem = (T[])new Object[10];
    }

    public void push(T item) {
        if (isFull()) {
            System.out.println("溢出");
            return;
        }
        this.elem[top++] = item;
    }

    public T pop() {
        if (empty()) {
            throw new RuntimeException("栈为空");
        }
        T ret = this.elem[top-1];
        this.top--;
        //这里置空防止T是个引用类型
        this.elem[top] = null;
        return ret;
    }

    public T peek() {
        if (empty()) {
            throw new RuntimeException("栈为空");
        }
        return this.elem[top-1];
    }

    public boolean empty() {
        if (top == 0) {
            return true;
        }else {
            return false;
        }
    }

    public boolean isFull() {
        if (top == elem.length) {
            return true;
        }else {
            return false;
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyStack<Integer> myStack = new MyStack<>();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        myStack.push(4);
        //System.out.println(myStack.pop());
        System.out.println(myStack.peek());
        System.out.println(myStack.pop());
        System.out.println(myStack.peek());
    }
}

运行结果

4
4
3

2.队列(Queue)

2.1 概念

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

在这里插入图片描述

2.2 方法

解释方法1方法2
入队列add(e)offer(e)
出队列remove()poll()
队首元素element()peek()

一般情况下方法2用的比较多

示例代码

public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.offer(5);
        queue.offer(6);
        queue.offer(7);
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue.peek());
        System.out.println(queue);
        System.out.println(queue.isEmpty());
    }

运行结果

[1, 2, 3, 5, 6, 7]
1
2
[2, 3, 5, 6, 7]
false

2.3 实现

队列也可以数组和链表结构实现，使用链表的结构实现更优一点，因为如果使用数组的结构，出队列在数组头上出，效率会很低
在这里插入图片描述
代码示例

class Node {
    public int val;
    public Node next;

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

class MyQueue {
    public Node head;
    public Node last;

    public void offer(int val) {
        Node node = new Node(val);
        if (head == null) {
            this.head = node;
            this.last = node;
        }else {
            this.last.next = node;
            this.last = this.last.next;
        }

    }

    public int poll() {
        int ret = this.head.val;
        if (head.next == null) {
            this.head = null;
            this.last = null;
            return ret;
        }else {
            this.head = this.head.next;
            return ret;
        }
    }

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

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

public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        myQueue.offer(1);
        myQueue.offer(2);
        myQueue.offer(3);
        myQueue.offer(4);
        System.out.println(myQueue.poll());
        System.out.println(myQueue.peek());
        System.out.println(myQueue.isEmpty());
 }

运行结果

1
2
false

转成泛型与上面同理

2.4 循环队列

假设我们现在想用数组实现一个队列，那么我们会发现如果每次假设数组头部出，尾部进，那么就会存在有空余的情况，那么这种情况到底是属于空还是满？我们就不好评判了，因此，要用数组实现，我们可以把数组看成是一个循环的数组，即就形成了循环队列

我们让front和rear分别代表队列的头和尾

  1. 刚开始的时候两个指针重合，此时队列为空
  2. 此时我们开始添加数据，每次添加一个，rear往后走一步
  3. 当rear和front相遇的时候我们可以判定为满，但是此时会出现一个问题，当我们rear和front只差一个位置的时候，此时再添加元素，rear会和front重合，按照我们的判断条件此时为空了，但是实际上整个队列里都放满数据，这里就有矛盾了
  4. 因此为了解决上述问题，我们可以通过放弃一个位置，即rear的下一位是front，此时我们就可以判定为满，如图所示便是满的，有了这样一个改变，我们给定的数组长度和实际可用会少一位，因此在实际使用的时候要达到预期长度，可以给长度加1
  5. 我们现在已经解决了判定是否未满的情况，但是通过看图，发现有很多小伙伴肯定会发现，此时当rear在数组最后位置上的时候，例如在图中7号位置上的时候，我们该怎样让rear移动呢？答案很简单，我们让此时rear每次移动它的下标加上1然后和整个数组的长度取模，即(rear+1)%数组.length，对于front来说也是一样的，即(front+1)%数组.length
    在这里插入图片描述
    示例代码
class MyCircularQueue {

    public int[] elem;
    public int front;
    public int rear;
   //构造方法
    public MyCircularQueue(int k) {
        this.elem = new int[k+1];
    }
    //入队
    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }else {
            elem[rear] = value;
            rear = (rear+1) % elem.length;
            return true;
        }
    }
    //出队
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }else {
            front = (front+1) % elem.length;
            return true;
        }
    }
    //显示对头
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return this.elem[front];
    }
	//显示队尾
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        int index = this.rear == 0 ? this.elem.length-1 : this.rear-1;
        return this.elem[index];
    }
    //判断是否为空
    public boolean isEmpty() {
        return front == rear;
    }
    //判断是否为满
    public boolean isFull() {
        return (this.rear+1) % this.elem.length == front;
    }
}

public class TestDemo3 {
    public static void main(String[] args) {
        MyCircularQueue myCircularQueue = new MyCircularQueue(8);
        myCircularQueue.enQueue(1);
        myCircularQueue.enQueue(2);
        myCircularQueue.enQueue(3);
        myCircularQueue.enQueue(4);
        myCircularQueue.enQueue(5);
        System.out.println(myCircularQueue.Front());
        System.out.println(myCircularQueue.Rear());
    }
}

运行结果

1
5

3.双端队列(Deque)

3.1 概念

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。

那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

3.2 方法

错误处理抛出异常返回特殊值抛出异常返回特殊值
入队列addFirst(e)offerFirst(e)addLast(e)offerLast(e)
出队列removeFirst()pollFirst()removeLast()pollLast()
获取元素getFirst()peekFirst()getLast()peekList()
南菇岭
关注
Java学习日记——实现二叉搜索树
sapere_aude的博客
07-04 154
import java.io.Serializable; import java.util.Arrays; import java.util.LinkedList; import java.util.concurrent.ConcurrentLinkedDeque; import sun.misc.Queue; /** * Java实现二叉树 * 要求实现的方法： * 泛型要求实现Comparable接口，可以比较两个对象的大小 * 判断二叉树是否为空； * 得到二叉树的节点数量 * 得到二叉树
严蔚敏版数据结构——队列（顺序表表示）
Cheney的博客
11-11 956
队列有两种表示方式，我们先看顺序表示： 代码中的rear（尾指针）与front（头指针）都是int 型的，它的作用就是做数组下标，我们习惯称它为指针，这里应该注意它不是指针类型。头指针始终指向队列头元素，尾指针始终指向队尾元素的下一个位置。 由于增加元素rear加一，删除元素front也加一，没错都是加一。就像一排10个座位，一开始只有前面三个座位有人，但我们的规则是：只能前面的同学离开，后来...
《大话数据结构》队列——只允许在一端进行插入操作，而在另外一端进行删除操作的线性表
热门推荐
喜欢打篮球的普通人
08-16 1万+
1.定义 队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表，简称：FIFO 符合生活习惯：排在第一个的优先出列，最后来的排在队伍后面     2.循环队列------队列的顺序存储结构 所谓的入队操作，就是在队尾追加一个元素，而不需要移动任何元素，因此时间复杂度为O(1)。 定义：把队列这种头尾相接的顺序存储结构称之为循环队列。 front指针指向队头元素，r...
Java学习日记17——集合、泛型
Andy24.的博客
08-15 160
Java学习日记17——集合、泛型 分类 Collection接口：两个子接口 List：记录元素的保存顺序，且可以有重复的元素 Set：不保存记录元素的顺序，且没有重复的元素 Map接口：即映射，键-值对的集合 collection接口的方法： add();//添加元素，返回布尔 remove();//删除元素，返回布尔 size();//获得大小，返回int isEmpty();//判断是否为空，返回布尔 contains();//判断是否包含某个元素，返回布尔 iterator();//遍历，返回i
JAVA学习日记(13)——优先级队列(堆)
qq_42986727的博客
11-16 155
1.二叉树的顺序存储 1.1 存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费 这种方式的主要用法就是堆的表示 例如上图，如果用数组来存储一般二叉树就会造成空间的浪费 1.2 下标关系 已知双亲(parent)的下标，则： 左孩子(left)下标 = 2 * parent + 1 右孩子(right)下标 = 2 * parent + 2 已知孩子（不区分左右）(child)下标，则： 双亲(parent)下标 = (chi
数据结构和算法学习日记——队列
我要，我要，我还要
09-09 167
队列特征 队列是一种特殊的线性表，可以用数组或链表来表示。 遵循先入先出的原则。 队列的插入操作位于队尾，队列的删除操作位于队首。 队列中的溢出 “下溢”现象：当队列为 空时，做出队运算时产生的溢出现象。 “真上溢”现象：当队列满时，做入队操作产生空间溢出的现象。 “假上溢”现象：由于入队和出队操作中，头尾指针都只向上移动，从而导致被删元素空间无法使用，此时若尾指针超过队列空间上界，则无法进...
【RabbitMQ学习日记】—— 初识RabbitMQ
欢迎来到我的世界
04-11 599
介绍了消息队列、简单工作模式、轮循工作模式，也包括如何安装配置 RabbitMQ（云服务器方式）
【RabbitMQ学习日记】——死信队列与延迟队列
欢迎来到我的世界
04-13 2264
介绍了死信队列与延迟队列的概念与用法，也包括通过死信队列实现延迟队列、通过占位符传参优化延迟队列、通过插件设置延迟队列等
学习日记2.0 —— 多线程
LZ有个好主意
08-27 148
多线程线程创建线程状态线程方法线程同步小知识小句子小故事 线程分为用户线程和守护线程。未设置setDaemon()的线程都为用户线程，虚拟机无须等待守护线程执行完毕。守护线程有垃圾回收，监控内存，日志审查… 线程创建 创建线程方式一：继承Thread类，重写run()方法； 创建线程方式二（推荐）：实现Runnable接口，重写run()方法； 其中涉及静态代理！ 好处:避免oop单继承局限性 创建线程方式三：实现Callable接口，重写call方法； 需要返回值类型以及抛出异常。 1.创建服务 2.提交
[宫水三叶的刷题日记]：队列1
08-03
在本文中，我们将深入探讨与队列相关的编程问题和解决方案，特别是如何利用队列来解决LeetCode上的第1047题——删除字符串中的所有相邻重复项。这道题目属于简单难度，涉及到的主要数据结构是栈和双端队列。 首先，...
JAVA学习日记(14)——java对象的比较
qq_42986727的博客
11-16 133
1.问题的提出 我们给定下面这样一段代码，拟定一副扑克牌，然后让它们之间进行比较 代码示例： class Card { public int rank;//数值 public String suit;//花色 public Card (int rank,String suit) { this.rank = rank; this.suit =suit; } } public class TestDemo1 { public static void main(String[] args)
业务日记——延时队列/延时消费
Luffyu的博客
05-11 1123
一、基本定义 延时/定时消息是指生产者(producer)发送消息到server后，server并不将消息立即发送给消费者(consumer)，而是在producer指定的时间之后送达。 二、常用的使用场景 任务超时处理。例如 订单系统中，如果某个用户在 30分钟内没有支付，则订单自动进行过期处理 任务延时处理。例如订餐系统中，下单成功60s之后 给用户发短信通知 定时任务。例如现在通过手机...
2024全新Java学习路线图一条龙（视频+课件+源码资料）
码农王也的博客
04-25 1639
互联网浩瀚无际，你能来到这里，是机遇也是缘分，机遇，就像我的标题一样，你找到了一份Java 360度无死角的 Java 学习路线，而缘分让我们相遇，注定给你的学习之路搭上一把手，送你一程。整条线路除了拥有后端整个技术体系外，还涵盖了前端、大数据、云计算、运维等各大领域。在这十八般武艺汇聚全身的同时，这条学习路线也拥有着独有的特色和着重点，比如加入了极为重要且业内稀缺的基本功修炼——六套计算机基础类课程。还有多套Java基础类课程，多维度讲解帮助学习者入门。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 233
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 465
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 559
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 564
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 813
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
递归工作栈与数据结构——栈和队列解析
"这篇内容主要介绍了C语言中的数据结构——栈和队列，特别是递归工作栈的概念。栈是一种后进先出（LIFO）的数据结构，常用于递归调用中的存储。" 栈和队列是计算机科学中两种基本的数据结构。栈是一种特殊的线性表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值