《Java初阶数据结构》----4.＜线性表---Stack栈和Queue队列＞

news2024/11/15 18:40:29

前言

      大家好，我目前在学习java。之前也学了一段时间，但是没有发布博客。时间过的真的很快。我会利用好这个暑假，来复习之前学过的内容，并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论！！！

      喜欢我文章的兄弟姐妹们可以点赞，收藏和评论我的文章。喜欢我的兄弟姐妹们以及也想复习一遍java知识的兄弟姐妹们可以关注我呦，我会持续更新滴，
     望支持！！！！！！一起加油呀！！！！

语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！

学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！

本篇博客主要讲解Java基础语法中的

一、栈

1. 栈的概念

2. 栈的使用

3. 栈的模拟实现

4. 栈的常见编程题

二、队列

1. 队列的概念

2. 队列的使用

3.队列的模拟实现

4.队列的循环设计

三、双端队列

一、栈（stack）

1.1 栈的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

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

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

 

Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安 全的。 

1.2 栈的使用 

代码示例：

public static void main(String[] args) {
    Stack<Integer> s = new Stack();
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    System.out.println(s.size());   // 获取栈中有效元素个数---> 4
    System.out.println(s.peek());   // 获取栈顶元素---> 4
    s.pop();   // 4出栈，栈中剩余1   2   3，栈顶元素为3
    System.out.println(s.pop());   // 3出栈，栈中剩余1 2   栈顶元素为3
    if(s.empty()){
        System.out.println("栈空");
   }else{
        System.out.println(s.size());
   }
}

1.3 栈的模拟实现

 变量的定义、包含定义一个数组存储栈、记录栈中元素个数、

定义一个静态常量便于初始化栈

    private int[] elem;//定义一个数组来存储栈中元素
    private int useSize;//记录栈中元素
    private static final int DEFAULT_CAPACITY = 10;//定义一个静态常量

 获取栈的长度的方法

    public int getUseSize() {
        return useSize;
    }

栈的有参构造方法。构造一个容量为DEFAULT_CAPACITY的栈

    //构造一个容量为DEFAULT_CAPACITY的栈
    public MyStack(){
        this.elem = new int[DEFAULT_CAPACITY];
    }

检测栈是否满了 

    //检测栈是否满了
    private boolean isFull(){
        return this.useSize == this.elem.length;
    }

 入栈：将val放入栈

    //将val放入栈
    public void push(int val){
        if (isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[useSize++] = val;
    }

出栈： 将栈顶元素取出并返回

    //将栈顶元素取出并返回
    public int pop(){
        if (isEmpty()){
            throw new EmptyException("Stack为空！");
        }
        return elem[--useSize];
    }

获取栈顶元素

    //获取栈顶元素
    public int peek(){
        if (isEmpty()){
            throw new EmptyException("Stack为空！");
        }
        return elem[useSize-1];
    }

检测栈是否为空

    //检测栈是否为空
    private boolean isEmpty(){
        return this.useSize == 0;
    }

1.4 栈的常见编程题

1.有效的括号

    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>(); 
//判断是否为有效的括号，具有先进后匹配的特点，因此我们用栈。首先创建一个栈
        int len = s.length(); //首先得到字符串长度
        if (len == 0) {       //如果字符串为空，则返回true
            return true;
        }
        if (len % 2 == 1) {   //括号成双成对，因此如果字符串为奇数，那么直接返回false
            return false; 
        } else {     //如果为偶数，符合预期则，将字符串转字符数组。遍历这个字符数组
            char[] chars = s.toCharArray();
            for (char ch : chars
            ) {            
                if (ch == '(' || ch == '[' || ch == '{') { //如果为左括号，则入栈。
                    stack.push(ch);
                }
                if (!stack.empty()) { //如果有左括号，到这里栈一定不为空。如果栈为空，则返回false，因为先得有左括号才会是有效括号
                //接下来判断右括号，如果遍历到右括号，那么必有栈顶元素与之配对才会是有效括号，并出栈栈顶元素。否则返回false。
                    if (ch == '}') {
                        if (stack.pop() != '{') {
                            return false;
                        }
                    }
                    if (ch == ']') {
                        if (stack.pop() != '[') {
                            return false;
                        }
                    }
                    if (ch == ')') {
                        if (stack.pop() != '(') {
                            return false;
                        }
                    }
                } else { 
                    return false;
                }
            }
        } 
        //最终判断栈是否为空，若全是左括号，那么就没有出栈。因此如果栈内有元素则为false。若匹配成功
        //栈为空，返回true
        return stack.empty();
    }

2.逆波兰表达式求值

import java.util.Stack;
//运算方法是将数字入栈，如果碰到运算符号。则出栈将第一个出栈元素放在运算符右边，第二个出栈元素放入运算符左边
//计算这个结果，并将这个计算结果入栈。重复以上操作。即可计算出逆波兰表达式的值。
public class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        int right;
        int left;   
        for (String token:tokens
             ) {
            switch (token){
                case "+":
                    stack.push(stack.pop()+stack.pop());
                    break;
                case "-":
                    right = stack.pop();
                    left = stack.pop();
                    stack.push(left-right);
                    break;
                case "*":
                    stack.push(stack.pop()*stack.pop());
                    break;
                case "/":
                    right = stack.pop();
                    left = stack.pop();
                    stack.push(left/right);
                    break;
                default:stack.push(Integer.parseInt(token)); //注意这里放入栈的时候要将字符串转整型类型
            }
        }
        return stack.peek();
    }
}

1.运算方法是将数字入栈，如果碰到运算符号。则出栈将第一个出栈元素放在运算符右边，第二个出栈元素放入运算符左边
2.计算这个结果，并将这个计算结果入栈。重复以上操作。即可计算出逆波兰表达式的值。

3.栈的压入、弹出序列 

import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        int n = pushA.length;
        //辅助栈
        Stack<Integer> s = new Stack<>();
        //遍历入栈的下标
        int j = 0;
        //遍历出栈的数组
        for(int i = 0; i < n; i++){
            //入栈：栈为空或者栈顶不等于出栈数组
            while(j < n && (s.isEmpty() || s.peek() != popA[i])){
                s.push(pushA[j]);
                j++;
            }
            //栈顶等于出栈数组
            if(s.peek() == popA[i])
                s.pop();
            //不匹配序列
            else
                return false;
        }
        return true;
    }
}

4.最小栈

class MinStack {
    Deque<Integer> xStack;
    Deque<Integer> minStack;

    public MinStack() {
        xStack = new LinkedList<Integer>();
        minStack = new LinkedList<Integer>();
        minStack.push(Integer.MAX_VALUE);
    }
    
    public void push(int x) {
        xStack.push(x);
        minStack.push(Math.min(minStack.peek(), x));
    }
    
    public void pop() {
        xStack.pop();
        minStack.pop();
    }
    
    public int top() {
        return xStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

1.5栈的应用场景

将递归转化为循环

比如：逆序打印链表

递归方式

// 递归方式
void printList(Node head){
    if(null != head){
        printList(head.next);
        System.out.print(head.val + " ");
   }
}

循环方式

// 循环方式
void printList(Node head){
    if(null == head){
        return;
   }
    
    Stack<Node> s = new Stack<>();
    // 将链表中的结点保存在栈中
    Node cur = head;
    while(null != cur){
        s.push(cur);
        cur = cur.next;
   }
    // 将栈中的元素出栈
    while(!s.empty()){
        System.out.print(s.pop().val + " ");
   }
}

二、队列 

2.1队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)。

入队列：进行插入操作的一端称为队尾（Tail/Rear）

出队列：进行删除操作的一端称为队头 （Head/Front）

 

 

在Java中，Queue是个接口，底层是通过链表实现的。

2.2 队列的使用 

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。 

public static void main(String[] args) {
    Queue<Integer> q = new LinkedList<>();
    q.offer(1);
    q.offer(2);
    q.offer(3);
    q.offer(4);
    q.offer(5);                  // 从队尾入队列
    System.out.println(q.size());
    System.out.println(q.peek());  // 获取队头元素
    
    q.poll();
    System.out.println(q.poll());  // 从队头出队列，并将删除的元素返回
    
    if(q.isEmpty()){
        System.out.println("队列空");
   }else{
        System.out.println(q.size());
   }
}

2.3 队列模拟实现

队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有 两种：顺序结构 和 链式结构。思考下：队列的实现使用顺序结构还是链式结构好？ 

 

 定义变量、用内部类定义队列的的节点、队头、队尾、队员数

    static class ListNode{
        private int val;
        private ListNode prev;
        private ListNode next;

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

    private ListNode front;//队头
    private ListNode rear;//队尾

    private int useSize;//队员数

    }

得到队员数 

    public int getUseSize() {
        return useSize;
    }

入队

    //入队操作，相当于头插法
    public void offer(int x){
        ListNode node = new ListNode(x);
        if(front == null){
            front = rear = node;
        }else {
            node.next = front;
            front.prev = node;
            front = node;
        }
        useSize++;
    }

出队

    //出队操作，相当于删除尾节点
    public int poll(){
        if(rear == null){
            return -1;
        }
        int ret = rear.val;
        if(front == rear){
            front = null;
            rear = null;
            return ret;
        }
        rear = rear.prev;
        rear.next = null;
        useSize--;
        return ret;
    }

获取队头元素 

    //获取队头元素
    public int peek(){
        if(front == null){
            return -1;
        }
        return front.val;
    }

检测队列是否为空 

    //检测队列是否为空
    public boolean isEmpty(){
        return this.useSize == 0;
    }

2.4 循环队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解的生产者消费者模型就可以就会使用循环队列。 环形队列通常使用数组实现。

 

数组下标循环的小技巧  

1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length

2. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length  

 

如何区分空与满 

1. 通过添加 size 属性记录

2. 保留一个位置

3. 使用标记 

 

 三、双端队列 (Deque)

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

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

Deque是一个接口，使用时必须创建LinkedList的对象。 

 

在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口。 

Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现

 2.5设计循环队列

class MyCircularQueue {
    private int front;
    private int rear;
    private int capacity;
    private int[] elements;

    public MyCircularQueue(int k) {
        capacity = k + 1;
        elements = new int[capacity];
        rear = front = 0;
    }

    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }
        elements[rear] = value;
        rear = (rear + 1) % capacity;
        return true;
    }

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

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

    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return elements[(rear - 1 + capacity) % capacity];
    }

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

    public boolean isFull() {
        return ((rear + 1) % capacity) == front;
    }
}

四、面试题 

1.用队列实现栈

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}

2.用栈实现队列

 

class MyQueue {
    Deque<Integer> inStack;
    Deque<Integer> outStack;

    public MyQueue() {
        inStack = new ArrayDeque<Integer>();
        outStack = new ArrayDeque<Integer>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }

    public int peek() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void in2out() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1946889.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

＜数据集＞抽烟识别数据集＜目标检测＞

＜数据集＞抽烟识别数据集＜目标检测＞

数据集格式&#xff1a;VOCYOLO格式 图片数量&#xff1a;4860张 标注数量(xml文件个数)&#xff1a;4860 标注数量(txt文件个数)&#xff1a;4860 标注类别数&#xff1a;1 标注类别名称&#xff1a;[smoking] 使用标注工具&#xff1a;labelImg 标注规则&#xff1a;对…
阅读更多...
高三了，无计算机基础能学计算机吗？

高三了，无计算机基础能学计算机吗？

高三阶段学习计算机编程是完全可行的&#xff0c;即使你没有任何计算机基础。我收集制作一份C语言学习包&#xff0c;对于新手而言简直不要太棒&#xff0c;里面包括了新手各个时期的学习方向&#xff0c;包括了编程教学&#xff0c;数据处理&#xff0c;通信处理&#xff0c;技…
阅读更多...
mysql面试（五）

mysql面试（五）

前言 本章节从数据页的具体结构&#xff0c;分析到如何生成索引&#xff0c;如何构成B树的索引结构。 以及什么是聚簇索引&#xff0c;什么是联合索引 InnoDB数据结构 行数据 我看各种文档中有好多记录数据结构的&#xff0c;但是这些都是看完就忘的东西。在这里详细讲也没…
阅读更多...
【进阶篇-Day12：JAVA中stream流、File类的介绍】

【进阶篇-Day12：JAVA中stream流、File类的介绍】

目录 1、stream流1.1 stream流的作用1.2 stream流的思想1.3 获取stream流对象1.4 stream流中间操作方法1.5 stream流终结操作方法1.6 stream收集操作1.7 stream的综合案例 2、File类2.1 File类创建文件对象2.2 File类的常用方法2.3 File类的创建和删除方法2.4 File类的遍历方法…
阅读更多...
volatile与JMM

volatile与JMM

目录 volatile特点volatile内存语义volatile为什么可以保证可见性和有序性呢&#xff1f;内存屏障屏障分类粗分两种屏障细分四种屏障 volatile特性案例说明如何正确使用volatile总结 volatile特点 被volatile修饰的变量有2大特点&#xff1a;可见性和有序性&#xff08;禁重排…
阅读更多...
nginx even块的配置

nginx even块的配置

events 块是 Nginx 配置文件 (nginx.conf) 中的重要部分&#xff0c;用于配置与事件处理相关的参数。它主要定义了 Nginx 服务器如何处理客户端连接&#xff0c;以及控制工作进程的行为。这些配置对于优化服务器性能和稳定性至关重要。 accept_mutex 设置Nginx网络连接序列化 …
阅读更多...
leetcode-二分查找算法总结

leetcode-二分查找算法总结

最朴素二分查找算法&#xff1a; 最朴素二分查找算法: 最基础的一道题:基于有序数组的二分查找--. - 力扣&#xff08;LeetCode&#xff09; 基本流程: 1:实际上二分查找不一定非得要有序&#xff0c;能否使用二分查找的关键是是否具有二段性. 2:基于有序数组的二分查找算…
阅读更多...
jetbrains 、IntelliJ IDEA、PyCharm 等工具英语音译读音

jetbrains 、IntelliJ IDEA、PyCharm 等工具英语音译读音

本心、输入输出、结果 文章目录 jetbrains 、IntelliJ IDEA、PyCharm 等工具英语音译读音前言jetbrains 、IntelliJ IDEA、PyCharm 等工具英语音译读音jetbrains 、IntelliJ IDEA、PyCharm 等工具英语音译读音 编辑 | 简简单单 Online zuozuo 地址 | https://blog.csdn.net/qq_…
阅读更多...
谷粒商城实战笔记-55-商品服务-API-三级分类-修改-拖拽数据收集

谷粒商城实战笔记-55-商品服务-API-三级分类-修改-拖拽数据收集

文章目录 一&#xff0c;拖拽后结点的parentCid的更新二&#xff0c;拖拽后结点的父节点下所有结点的sort排序属性的变化更新排序的逻辑代码分析 三&#xff0c;拖拽后结点及其子节点catLevel的变化判断是否需要更新 catLevel获取拖动后的新节点 更新 catLevel完整代码 这一节的…
阅读更多...
服务器数据恢复—V7000存储硬盘故障脱机的数据恢复案例

服务器数据恢复—V7000存储硬盘故障脱机的数据恢复案例

服务器存储数据恢复环境&#xff1a; 某品牌P740小型机AIXSybaseV7000磁盘阵列柜&#xff0c;磁盘阵列柜中有12块SAS机械硬盘&#xff08;其中包括一块热备盘&#xff09;。 服务器存储故障&#xff1a; 磁盘阵列柜中有一块磁盘出现故障&#xff0c;运维人员用新硬盘替换掉故障…
阅读更多...
【安当产品应用案例100集】003-基于SSL VPN架构，通过ASP Radius认证机制强化远程办公

【安当产品应用案例100集】003-基于SSL VPN架构，通过ASP Radius认证机制强化远程办公

SSL VPN远程安全接入技术&#xff0c;想必大家都已有所耳闻。简而言之&#xff0c;这项技术允许你在家中或其他远程位置&#xff0c;通过安全、可靠的途径访问公司内部的网络资源&#xff0c;从而实现无缝、无差别的远程办公体验。它作为企业远程访问的优选方案&#xff0c;其简…
阅读更多...
SpringBoot热部署重启关闭(DevTools)

SpringBoot热部署重启关闭(DevTools)

一、DevTools依赖 1、DevTools简介 在Spring Boot项目中&#xff0c;spring-boot-devtools模块提供了多种开发时的便利功能&#xff0c;其中最显著的是restart和livereload特性&#xff0c;它们分别用于应用代码的热重启和前端资源的即时重载。 devtools依赖&#xff1a; &l…
阅读更多...
UCOSIII 时间片轮调度接口OS_SchedRoundRobin详解

UCOSIII 时间片轮调度接口OS_SchedRoundRobin详解

时间片轮调度&#xff08;Round-Robin Scheduling&#xff09;是一种常见的任务调度算法&#xff0c;它将CPU时间片均匀地分配给每个任务&#xff0c;确保每个任务在一定时间内能够获得CPU资源。这种调度方式适用于需要公平分配CPU时间的系统&#xff0c;特别是在有多个相同优先…
阅读更多...
叶再豪老师-【番外篇-主升三域】课程

叶再豪老师-【番外篇-主升三域】课程

文章目录 1.番外篇1.1番外篇:【道篇】1.1.1 课程目录1.1.2 大道至简1.1.3 欲速则不达&#xff0c;见小利则大事不成1.1.4 强弱转换规律1.1.5 创战法以和道&#xff0c;成为简单快乐的投资者1.1.6 融合道&#xff0c;服务众生&#xff0c;离苦得乐 1.2 番外篇:【势篇】1.2.1 顺势…
阅读更多...
Adobe国际认证详解-从零开始学做视频剪辑

Adobe国际认证详解-从零开始学做视频剪辑

从零开始学做视频剪辑&#xff0c;是许多初学者面临的挑战。在这个数字媒体时代&#xff0c;视频剪辑已经成为一种重要的技能&#xff0c;无论是个人爱好还是职业发展&#xff0c;掌握视频剪辑技能都是非常有价值的。 视频剪辑&#xff0c;简称“剪辑”&#xff0c;是视频制作过…
阅读更多...
maven archetype

maven archetype

1.简介 maven脚手架是为了创建一个项目模板&#xff0c;以后新建项目都能够复用该模板 maven中模板引擎使用的是velocity,在文件中可以使用它的语法获取变量等操作 2.实现 单模块脚手架实现 pom.xml <?xml version"1.0" encoding"UTF-8"?> &…
阅读更多...
无人机之起飞过程操作

无人机之起飞过程操作

一、开启无人机电源 1、开启电源时&#xff0c;再次确认无人机各个部件工作正常&#xff0c;传感器未被遮挡&#xff1b; 2、将无人机放置在平坦的地面上&#xff0c;并开启电源。 二、进行预起飞检查 1、通过无人机的控制系统执行预起飞检查&#xff0c;包括检测罗盘、GPS…
阅读更多...
【Unity2D 2022：UI】无法拖拽TextMeshPro组件

【Unity2D 2022：UI】无法拖拽TextMeshPro组件

在预制体Card上挂载了四个Text Mesh Pro组件&#xff0c;分别命名为Name、HP、ATK、Description。 将预制体Card挂载脚本CardDisplay用来在预制体上显示属性&#xff0c;并创建TextMeshPro对象来接收TextMeshPro组件。 using TMPro; using UnityEngine; using UnityEngine.UI;…
阅读更多...
Air780EP模块 LuatOS开发-MQTT接入阿里云应用指南

Air780EP模块 LuatOS开发-MQTT接入阿里云应用指南

简介 本文简单讲述了利用LuatOS-Air进行二次开发&#xff0c;采用一型一密、一机一密两种方式认证方式连接阿里云。整体结构如图 关联文档和使用工具&#xff1a;LuatOS库阿里云平台 准备工作 Air780EP_全IO开发板一套&#xff0c;包括天线SIM卡&#xff0c;USB线 PC电脑&…
阅读更多...
Harmony Next -- 通用标题栏：高度自定义，可设置沉浸式状态，正常状态下为：左侧返回、居中标题，左中右均可自定义视图。

Harmony Next -- 通用标题栏：高度自定义，可设置沉浸式状态，正常状态下为：左侧返回、居中标题，左中右均可自定义视图。

hm_common_title_bar OpenHarmony三方库中心仓&#xff1a;https://ohpm.openharmony.cn/#/cn/detail/common_title_bar 介绍 一款通用标题栏&#xff0c;支持高度自定义&#xff0c;可设置沉浸式状态&#xff0c;正常状态下为&#xff1a;左侧返回、居中标题&#xff0c;左…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023