Java数据结构与算法——稀疏数组和队列

最新推荐文章于 2024-11-09 03:58:56 发布
最新推荐文章于 2024-11-09 03:58:56 发布
阅读量336 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 队列 链表 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42533238/article/details/105798820
版权

先认识一下线性结构和非线性结构的区别。

线性结构和非线性结构
线性结构
  1. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
  2. 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
  3. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
  4. 线性结构常见的有：数组、队列、链表和栈。
非线性结构

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

下面就是最简单的稀疏数组和队列了！

稀疏数组

在这里插入图片描述
这时就应该用稀疏数组解决，思路如下！
在这里插入图片描述

代码实现
public class SparseArray {

    public static void main(String[] args) {

        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[5][6] = 2;

        System.out.println("原始二维数组！");

        for (int[] row : chessArr1) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        //1. 遍历  原始的二维数组，得到有效数据的个数 sum
        int sum = 0;
        for (int[] row : chessArr1) {
            for (int data : row) {
                if (data != 0) {
                    sum++;
                }
            }
        }
        //2. 根据sum 就可以创建 稀疏数组 sparseArr   int[sum + 1] [3]
        int[][] sparseArr = new int[sum + 1][3];
        //3. 将二维数组的有效数据数据存入到 稀疏数组
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        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]);
        }


        //1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
        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();
        System.out.println("恢复后的二维数组------");
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

    }
}
队列
队列介绍

队列是一个有序列表，可以用数组或是链表来实现。
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

数组模拟队列

缺点：数组不能循环使用！

示意图：(使用数组模拟队列示意图)

在这里插入图片描述

代码实现：

public class ArrayQueueTest {

    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 '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 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; //指向队列头部的前一个位置
        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++;
        arr[rear] = n;
    }

    //获取队列的数据
    public int getQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列空，不能取数据！");
        }
        front++;
        return arr[front];
    }

    //显示队列的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列空，没有数据");
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d",i,arr[i]);
        }
    }

    //显示队列的第一个数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列空，没有数据");
        }
        return arr[front+1];
    }

}
数组模拟环形队列

数组可以循环使用！

示意图：(使用数组模拟环形队列示意图)

在这里插入图片描述

代码实现：

public class CircleArrayQueueTest {

    public static void main(String[] args) {

        CircleArray queue = new CircleArray(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;
    private int front;//队列头//指向队列头部的第一个位置
    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("队列空，不能取数据！");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    //显示队列的所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列空，没有数据");
        }
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    //求出当前队列的有效数据个数
    public int size() {
        return (rear + maxSize - front) % maxSize;
    }

    //显示队列的第一个数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列空，没有数据");
        }
        return arr[front];
    }

}
joker-Tian
关注
专栏目录
【笔记】数据结构与算法——稀疏数组
Gu_jiaguaren的博客
08-08 293
数据结构与算法——稀疏数组 Ø 数据结构包括： 1.线性结构： 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 线性结构常见的有：数组、队列、链表和栈 2.非线性结构： 包括：二维数组，多维数组，广义表，树结构，*图结构 ====>引生出多个算
数据结构预算法（稀疏数组和队列）
nigulas12138的博客
09-16 291
数据（data）结构（structure） 程序=数据结构+算法 数据结构： 线性 ：数组 链表 队列 栈 非线性：二位数组 多维数组 广义表 树结构 图结构 稀疏数组和队列(sparsearray)
Java实现稀疏数组
baolingye的博客
08-21 5480
一、线性结构 线性结构是最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同存储结构，即顺序存储结构和链式存储结构 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的,即在内存中是连续的，例如数组 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息，但好处是可以充分利用碎片地址 线性结构常见的有：数组、队列、链表和...
java数据结构和算法——稀疏数组和队列
qq_49922118的博客
03-10 260
稀疏数组 实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 因为该二维数组的很多值是默认值0(无棋子), 因此记录了很多没有意义的数据→稀疏数组。 队列
数据结构与算法·二 —— 稀疏数组和队列
un357951的博客
04-12 235
稀疏数组 二维数组压缩为稀疏数组 稀疏数组恢复为二维数组 队列 数组模拟队列 数组模拟循环队列 代码
数据结构与算法——稀疏数组与队列
skyshine94的博客
09-09 244
目录 一、稀疏数组 1.1基本介绍 1.2 稀疏数组的处理方式 1.3 二维数组与稀疏数组之间的转换 二、队列 2.1 基本介绍 2.2 数组模拟队列 2.3数组模拟环形队列 一、稀疏数组 1.1基本介绍 将数组中大部分元素为0或同一个值时，可以使用稀疏数组（SparseArray）来保存。 1.2 稀疏数组的处理方式 在第一行第一列记录数组共有几行几列，有几个不同值。 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。 1.3 二维数组与稀...
Java数据结构与算法:稀疏数组和队列
m0_50460160的博客
06-19 206
Java数据结构与算法——稀疏数组和队列。
【数据结构与算法】（JAVA版）时间、空间复杂度，数据结构，手撕一维数组的基本操作（增删改），稀疏数组应用场景——保姆级
m0_52586550的博客
05-15 347
废fa不多说，直接上货。 复杂度 评估算法优劣的核心指标： ​ 1.时间复杂度（算法流程决定） ​ 2.额外空间复杂度（算法流程决定） ​ 3.常数项时间（实现细节决定） 时间复杂度 常见的常数时间的操作 常见的算术运算(+、 -、x*、/、%等) 常见的位运算(>>、 >>>、<<、|、&、^等) 赋值、比较、自增、自减操作等. 数组寻址操作 总之，执行时间固定的操作都是常数时间的操作。 反之，执行时间不固定的操作，都不是常数时间的操作。 时间复杂度就是
【Java 数据结构与算法 01】稀疏数组和队列
qq_44153697的博客
08-17 203
本文为学习 Java 数据结构与算法所记录，主要内容为 稀疏数组和队列 的原理与应用
线性与非线性数据结构详解：稀疏数组与链表应用
本文档深入探讨了线性结构和非线性结构，以及在计算机科学中常用的两种数据结构——稀疏数组和链表（LinkedList）。首先，让我们理解什么是线性结构。线性结构是数据元素之间存在一对一关系的数据组织形式，常见的...
java数据结构和算法（二）稀疏数组、队列
feicongcong的博客
03-05 121
稀疏数组 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 队列 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出（FIFO）的原则。即：先存入队列的数据，要先取出。后存入的要后取出 数组模拟队...
数据结构 栈和队列
qq_67140973的博客
11-08 500
正文开始。
Java：数据结构-Lambda表达式
blamep的博客
11-08 538
lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
【数据结构与算法】第9课—数据结构之二叉树(链式结构)
weixin_70620792的博客
11-05 767
2为底，n+1为对数，n为二叉树节点数。
【STL栈和队列】：高效数据结构的应用秘籍
LH__1314的博客
11-05 953
C++ 标准模板库（STL）为我们提供了多种容器，其中stack（栈）和queue（队列）是非常常用的两种容器。根据之前C语言实现的栈和队列，（如有遗忘，请回去看看【数据结构】— 栈和队列-CSDN博客）我们知道一些栈和队列的逻辑，现在就来学习C++STL中的栈和队列。eque`（双端队列）既可以当作栈，也可以当作队列使用。我们可以在双端队列的两端进行插入和删除操作，从而更灵活地实现栈和队列的功能。​对于双端队列，简单来说，就是可以像vector那样随机访问，也可以像链表那样随机位置插入；
Java：数据结构-枚举
blamep的博客
11-08 365
枚举 概念：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式。 public static final int RED = 1; public static final int GREEN = 2; public static final int BLACK = 3; 枚举的使用 public enum enumTest { RED(0,"RED"),GREEN(1,"GREEN"),BLUE(2,"BLUE"), BLACK(3,"BLACK"),WHI
C语言实现数据结构之堆
0xFFFFFFFF
11-08 1389
在这篇文章，我们使用C语言实现了一个物理存储结构为动态顺序表，逻辑结构为二叉树的堆，并实现了堆排序——一种比较快的排序
数据结构-并查集专题（2）
最新发布
Beau_Will的博客
11-09 799
接（1）完成剩余题目和了解并查集运用求解最小生成树的Kruskal算法。
清华大学邓俊辉数据结构
11-08 409
它涵盖了从基础到进阶的各类数据结构知识，无论是线性表、栈、队列这些较为直观的结构，还是树、图等相对复杂且在实际应用中极为重要的结构，都有着详尽的讲解。无论是计算机专业的学生想要夯实数据结构基础，为后续的算法学习、软件开发等打下坚实的基础，还是其他对数据结构感兴趣的爱好者希望深入了解这一领域，清华大学邓俊辉老师的数据结构相关资源都是绝佳的选择。配套的教材也是一大亮点。视频中老师的讲解声情并茂，配合着精美的课件展示，能够让学习者在观看视频时仿佛置身于清华的课堂之中，跟随老师的思路一步步深入学习。
初阶数据结构【单链表及其接口的实现】
吴先生的博客
11-08 1244
在前面我们学到了数据结构中一个简单的数据结构—顺序表，通过我们对其的了解，我们不难知道，其实顺序表就是一个可以动态增长的数组，但是我们在对其进行增容时，往往增容是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。这期我们主要介绍了链表的相关概念和单链表的接口实现，下期我们将实现常用链表之一的双链表的接口实现；最后，祝26考研一战成硕，加油！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值