2021-09-26

最新推荐文章于 2025-05-08 18:58:39 发布
最新推荐文章于 2025-05-08 18:58:39 发布
阅读量81 收藏
点赞数
文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_57124899/article/details/120495997
版权
本文介绍了如何使用Java实现稀疏数组和队列。通过五子棋程序中的数据存储需求引入稀疏数组，详细解释了其原理和应用，包括从二维数组转换为稀疏数组以及恢复原始二维数组的过程。接着，讨论了队列的基本概念，给出了数组模拟队列的实现，包括普通数组队列和环形数组队列，展示了如何进行数据的添加和取出操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构

稀疏数组和队列

1.1 稀疏 sparsearray 数组

1.1.1先看一个实际的需求

? 编写的五子棋程序中，有存盘退出和续上盘的功能。

? 分析问题:
因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数组。

1.1.2基本介绍

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:

  1. 记录数组一共有几行几列，有多少个不同的值
  2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
    ? 稀疏数组举例说明

1.1.3应用实例

  1. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
  2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
  3. 整体思路分析
  4. 代码实现
package com.atguigu.sparsearray;

public class SparseArray {
    public static void main(String[] args){
        //创建一个原始的二维数组11*11
        //0：表示没有棋子，1 表示黑子 2 表示蓝子
        int chessArr1[][]=new int[11][11];
        chessArr1[1][2]=1;
        chessArr1[2][3]=2;
        //输出原始的二维数组
        System.out.println("原始的二维数组~~");
        for(int [] row:chessArr1){
            for(int data: row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
        //将二维数组转稀疏数组的思路
        //1.先遍历二维数组 得到非0数据的个数
        int sum=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    sum++;
                }
            }
        }
//        System.out.println("sum="+sum);
        //2.创建对应的稀疏数组
        int sparseArr[][]=new int[sum+1][3];
        //给稀疏数组赋值
        sparseArr[0][0]=11;
        sparseArr[0][1]=11;
        sparseArr[0][2]=sum;

        //遍历二维数组，将非0的值存放到sparseArr中
        int count=0;
        for(int i=0;i<11;i++){
            for(int j=0;j<11;j++){
                if(chessArr1[i][j]!=0){
                    count++;
                    sparseArr[count][0]=i;
                    sparseArr[count][1]=j;
                    sparseArr[count][2]=chessArr1[i][j];
                }
            }
        }
        //输出稀疏数组的形式
        System.out.println();
        System.out.println("得到的稀疏数组为~~~");
        for(int i=0;i<sparseArr.length;i++){
            System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
        }
        System.out.println();
        //将稀疏数组恢复成原始的二维数组
        //1，先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
        int chessArr2[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
        //2.在读取稀疏数组后几行的数据(从第二行开始），并赋给原始的二维数组即可
        for(int i=1;i<sparseArr.length;i++){
            chessArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
        }
        //输出恢复后的二维数组
        System.out.println("恢复后的二维数组~~");
        for(int [] row:chessArr2){
            for(int data: row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }
}

1.2 队列

1.2.1队列的一个使用场景

银行排队的案例:

1.2.2队列介绍

  1. 队列是一个有序列表，可以用数组或是链表来实现。
  2. 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
  3. 示意图：(使用数组模拟队列示意图)

1.2.3数组模拟队列思路

? 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队
列的最大容量。
? 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 及 rear 分别记录队列前后端的下标，
front 会随着数据输出而改变，而 rear 则是随着数据输入而改变，
? 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析

  1. 将尾指针往后移：rear+1 , 当 front == rear 【空】
  2. 若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。
    rear == maxSize - 1[队列满]
    ? 代码实现
package com.atguigu.queue;

import java.util.Scanner;

class ArrayQueueDemo{
    public static void main(String[] args){
        //测试一把
        //创建一个队列
        ArrayQueue queue=new ArrayQueue(3);
        char key=' ';//接收用户输入
        Scanner scanner=new Scanner(System.in);
        boolean loop=true;
        while (loop){
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            key =scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop=false;
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value =scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res=queue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);

                    }catch (Exception e) {
                        System.out.println(e.getMessage());

                    }
                    break;
                case 'h'://查看队列头的数据
                    try{
                        int res =queue.headQueue();
                        System.out.printf("队列头的数据是%d\n",res);
                    }catch (Exception e) {
                        System.out.println(e.getMessage());

                    }


                    break;
                default:
                        break;
            }
        }
        System.out.println("程序退出~~s");


    }
}


//使用数组模拟队列-编写一个叫做arrayqueue类
class ArrayQueue{
    private int maxSize;//表示数组的最大容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数组用于存放数据，模拟队列

    //创建队列的构造器
    public ArrayQueue(int arrMaxSize){
        maxSize=arrMaxSize;
        arr=new int[maxSize];
        front=-1;//指向队列头部，分析出front是指向队列头的前一个位置
        rear=-1;//指向队列尾，指向队列尾的数据（即就是队列最后一个数据）

    }
    //判断队列是否满
    public boolean isFull(){
        return rear==maxSize-1;
    }
    //判断队列是否为空
    public boolean isEmpty(){
        return rear==front;
    }
    //添加数据到队列
    public void addQueue(int n){
        //判断队列是否满
       if(isFull()){
           System.out.println("队列满，不能加入数据~");
           return;
       }
       rear++;//让rear后移
        arr[rear]=n;
    }
    //获取队列的数据，出队列
    public int getQueue(){
        //判断队列是否空
        if(isEmpty()){
            //通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
        front++;//front后移
        return arr[front];
    }
    //显示队列的所有数据
    public void showQueue(){
        //遍历
        if(isEmpty()){
            System.out.println("队列空的，没有数据~~~");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    //显示队列的头数据。注意不是取出数据
    public int headQueue(){
        //判断
        if(isEmpty()){
            throw new RuntimeException("队列空的，没有数据~~~");
        }
        return arr[front+1];
    }
}

? 问题分析并优化

  1. 目前数组使用一次就不能用， 没有达到复用的效果
  2. 将这个数组使用算法，改进成一个环形的队列 取模：%

1.2.4数组模拟环形队列

对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)
? 分析说明：

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的
    时候需要注意 (rear + 1) % maxSize == front 满]
  2. rear == front [空]
  3. 分析示意图
    ? 代码实现
package com.atguigu.queue;

import java.util.Scanner;

public class CircleArrayQueue {
    public static void main(String[] args) {
//测试一把
        System.out.println("测试数组模拟环形队列的案例~~~");
// 创建一个环形队列
        CircleArray queue = new CircleArray(4); //说明设置 4, 其队列的有效数据最大是 3
        char key = ' '; // 接收用户输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop = true;
// 输出一个菜单
        while (loop) {
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取出数据");
            System.out.println("h(head): 查看队列头的数据");
            key = scanner.next().charAt(0);// 接收一个字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g': // 取出数据
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
// TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': // 查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
// TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e': // 退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}
class CircleArray {
    private int maxSize; // 表示数组的最大容量
//front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
//front 的初始值 = 0
private int front;
    //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定. //rear 的初始值 = 0
    private int rear; // 队列尾
    private int[] arr; // 该数据用于存放数据, 模拟队列
    public CircleArray(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }
    // 判断队列是否满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }
    // 判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
    // 添加数据到队列
    public void addQueue(int n) {
// 判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能加入数据~");
            return;
        }
//直接将数据加入
        arr[rear] = n;
//将 rear 后移, 这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }
    // 获取队列的数据, 出队列
    public int getQueue() {
        // 判断队列是否空
        if (isEmpty()) {
// 通过抛出异常
            throw new RuntimeException("队列空，不能取数据");
        }
// 这里需要分析出 front 是指向队列的第一个元素
// 1. 先把 front 对应的值保留到一个临时变量
// 2. 将 front 后移, 考虑取模
// 3. 将临时保存的变量返回
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }
    // 显示队列的所有数据
    public void showQueue() {
// 遍历
        if (isEmpty()) {
            System.out.println("队列空的，没有数据~~");
            return;
        }
// 思路：从 front 开始遍历，遍历多少个元素
// 动脑筋
        for (int i = front; i < front + size() ; i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }
    // 求出当前队列有效数据的个数
    public int size() {
// rear = 2
// front = 1
// maxSize = 3
        return (rear + maxSize - front) % maxSize;
    }
    // 显示队列的头数据， 注意不是取出数据
    public int headQueue() {
// 判断
        if (isEmpty()) {
            throw new RuntimeException("队列空的，没有数据~~");
        }
        return arr[front];
    }
}
2021-09-26 WPF上位机 45-关键帧动画
微软MVP Eleven
09-26 3万+
关键帧动画 1、简单线性动画的升级 String TextBlock -》 Text 同步执行 类型+Animation 17种 类型+AnimationUsingKeyFrames 22种 （1）关键帧动画所支持的类型比简单线性动画多 （2）关键帧 可以让定义的动画子项顺序执行 2、关键帧动画结构 简单动画：定义动画类、设置相关属性、触发 关键帧动画：定义动画类、包含关键帧对象 关键帧类型 1、Linear+【类型名称】+KeyFrame 线性变化关键帧，（简单线性动画的处理基本一样） 2、Discre.
2021-09-26 WPF上位机 46-路径动画和自定义帧动画
热门推荐
微软MVP Eleven
09-26 3万+
路径动画 根据Path数据，限定动画路径 动画类名称：类型名称+ AnimationUsingPath 三种类型： DoubleAnimationUsingPath MatrixAnimationUsingPath PointAnimationUsingPath 自定义帧动画 1、关键对象：CompositionTarget 动画时钟 <Window x:Class="Zhaoxi.AnimationStudy.Window7" xmlns="http://schemas.micro.
DSA
专注计算机体系结构
04-20 7914
评估处理器性能的指标：程序运行时间 程序运行时间的决定因素： 程序指令数：由程序代码、编译器、ISA决定平均指令执行周期数（CPI）：由ISA以及微架构决定。时钟周期：由微架构以及半导体制造工艺决定。 摩尔定律使得处理器晶体管数持续上升，但是因为晶体管功耗和晶体管面积缩小的速度基本相同，因此前40年间芯片单位面积的功耗基本不变。 目前，三种技术趋势让传统的通用处理器演进遇到了瓶
第一章：稀疏数组和队列
hua_hao的博客
10-03 186
1 稀疏 sparsearray 数组 1.1 先看一个实际的需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据==>稀疏数组。 1.2 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不...
2021-09-26 四位二进制计数器
He_wowo的博客
09-26 784
【2021-09-18】网易秋招笔试四道编程题
试问道几许
09-19 1659
通知：最新的秋招笔试编程题题目、思路以及参考代码已经全部整理好放在【TechGuide】了，私信公众号回复【网易】或者【百度】即可获得最实时的笔试题解啦！ 通知：最新的秋招笔试编程题题目、思路以及参考代码已经全部整理好放在【TechGuide】了，私信公众号回复【网易】或者【百度】即可获得最实时的笔试题解啦！ 通知：最新的秋招笔试编程题题目、思路以及参考代码已经全部整理好放在【TechGuide】了，私信公众号回复【网易】或者【百度】即可获得最实时的笔试题解啦！ 通知：最新的秋招笔试编程题题目.
2021-01-18
weixin_54641072的博客
01-18 1968
找程序猿哥哥！！！！编制App或者小程序
2021-09-22
weixin_46482214的博客
09-22 4834
Centos7扫描漏洞及离线处理方法漏洞处理方法nginx 安 全 漏 洞 (CVE-2021-23017)下载需要安装的离线包pcre安装openssl安装zlib安装nginx升级安装上述完成以后，会在当前我解压缩nginx的objs下面产生一个nginx二进制文件Apache Druid未授权访问【 原理扫 描 】处理方法OpenSSH CBC模式信息泄露漏洞(CVE-2008-5161)【 原理扫 描 】ICMP timestamp请求响应漏洞允许Traceroute探测SSH版本信息可被获取探测到
WordPress BuddyPress 越权漏洞RCE（CVE-2021-21389）
Biu_Biu_Bi的博客
07-15 1815
BuddyPress 是一个用于构建社区站点的开源 WordPress 插件。在 7.2.1 之前的 5.0.0 版本的 BuddyPress 中，非特权普通用户可以通过利用 REST API 成员端点中的问题来获得管理员权限。该漏洞已在 BuddyPress 7.2.1 中修复。插件的现有安装应更新到此版本以缓解问题。
中小学数学学习相关书籍-2021-09-26(H)-123页.pdf
09-26
数学作为中小学教育的核心学科之一，对于孩子们的逻辑思维、抽象思维和解决问题的能力培养起着至关重要的作用。随着教育的不断进步，为了满足不同年龄段学生在数学学习上的需求，一系列精心设计的数学学习相关书籍...
中国智能驾驶行业洞察2021[2021-09-07]（26页）.pdf
05-26
这份26页的报告涵盖了多个关键知识点，以下是其中的要点概括： 1. **智能驾驶市场发展**：报告指出，截至2021年8月，中国的智能驾驶行业已取得了显著进展，超过99.9%的用户通过应用程序（APP）进行交互，这显示出...
2021-09-26-MCU
a_zxswer的博客
11-08 252
tip1: GPIO的置位不要放在中断里； tip2:全局变量放在中断服务函数里， 要小心处理，使用volatile（类型修饰符，确保不会被编译器优化）声明；
在多线程环境下如何设计共享数据结构保证原子操作与数据一致性
windowshht的博客
05-03 570
在现代软件开发中，多线程编程是提升程序性能和响应速度的重要手段。然而，多线程环境下的。，不会出现并发冲突。但在多线程环境中，多个线程可能同时访问和修改共享数据，导致。在多线程环境下，共享数据一致性至关重要。极具挑战性，若处理不当，可能引发。Python 提供多种方法确保。在单线程环境中，数据操作。
数据结构小扫尾——栈
2401_87805056的博客
05-05 1147
线性表是一种最基础的数据结构，它由具有相同特性的数据元素构成，这些数据元素之间存在着线性关系，即第一个元素称为表头，最后一个元素称为表尾，除第一个元素外，每个元素有且只有一个前驱，除最后一个元素外，每个元素有且只有一个后继。线性表可以顺序存储，也可以链式存储。栈是一种特殊的线性表，它满足后进先出的特性，即最后被插入的元素最先被删除。栈的插入和删除操作都只能在栈顶进行。就像一个桶。我们把东西按顺序放进去，最后一个就放在了桶的最顶端。我们需要拿出来的时候，先拿出来最后放进去的，最后拿出来第一个放进去的。
【算法基础】选择排序算法 - JAVA
qq_38955667的博客
05-02 1279
选择排序首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。选择排序是一种简单直观的排序算法，核心思想是不断从未排序区域中选择最小元素放入已排序区域。核心要点时间复杂度始终为 O(n²)，无论输入如何空间复杂度为 O(1)，是一种原地排序算法交换次数较少，最多进行 n-1 次交换实现简单，代码易于理解和编写对于大型数据集不推荐使用。
【数据结构】励志大厂版·初阶（复习+刷题）：栈与队列
月亮永悬不落，剑指巅峰
05-02 5239
本篇文章主要复习栈、队列的实现，内含其顺序、链式结构的实现分析，基本操作的图文讲解，不仅仅是代码的板书，还有细节注释，理解每一行代码。重点讲述了整体的思路，各自的存储特点，在文章末尾还精选了几道练习题，学习知识点的实际使用
数据结构之线性表
bai_lan_ya的博客
05-07 469
数据结构链表存储方式和顺序存储方式
数据结构 - 9（ 位图 && 布隆过滤器 && 并查集 && LRUCache 6000 字详解 ）
最新发布
weixin_73232539的博客
05-08 857
数据结构第九篇，位图 && 布隆过滤器 && 并查集 && LRUCache 6000 字详解
有一个表A ，有字段date，值是 2023-01-31,2023-02-28,2023-03-06， 还有一个表B，有金额和日期两个字段，值是2023-03-09 00:00:00.000000 47260 2022-12-29 00:00:00.000000 28566 2022-08-01 00:00:00.000000 3378.7 2023-03-29 00:00:00.000000 4296 2023-03-06 00:00:00.000000 2369 2022-12-26 00:00:00.000000 51100 2023-02-07 00:00:00.000000 33057 2021-08-11 00:00:00.000000 11500 2022-04-14 00:00:00.000000 23219.8 2022-02-09 00:00:00.000000 100010 2021-12-31 00:00:00.000000 59100 写一个oracle sql 计算B表的日期分别在表A中的每个日期的前一年到该日期时间的B表的金额的总和
06-07
可以使用Oracle的日期函数和子查询来解决这个问题。以下是一个可能的SQL语句： ``` SELECT A.date, SUM(B.amount) AS total_amount FROM A, B WHERE B.date BETWEEN ADD_MONTHS(A.date, -12) AND A.date ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值