算法与数据结构(Java版)01-稀疏数组和队列详解及代码实现

置顶 已于 2022-04-18 20:33:45 修改
阅读量795 收藏 1
点赞数 3
分类专栏： 算法和数据结构 文章标签： java 算法 数据结构
于 2022-04-15 15:56:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43565087/article/details/124176299
版权

稀疏数组和队列-JAVA篇

1 稀疏数组

  • 所谓稀疏数组就是当数组中大部分的内容值都未被使用（或都为零），在数组中仅有少部分的空间使用。因此造成内存空间的浪费，为了节省内存空间，并且不影响数组中原有的内容值，我们可以使用稀疏数组去压缩数据。

1.1 稀疏数组的应用场景

在这里插入图片描述

1.2 稀疏数组的基本介绍

  • 当一个数组中大部分元素为0，或者为同一个数值时，可以使用稀疏数组来保存该数组
  • 稀疏数组的处理方法
    • 记录数组一共有几行几列，有多少个不同的值
    • 把具有不同值的元素的行列及记录在一个小规模的数组中从而缩小程序的规模

在这里插入图片描述

1.3 稀疏数组的应用

在这里插入图片描述

  • 将二维数组转换成稀疏数组

    • 遍历原有的二维数组，得知有效数据数据的总个数
    • 根据有效数据个数来创建稀疏数组 [有效数组+1]
    • 将二维数组中的有效数据存入到稀疏数组中
    • 将稀疏数组通过IO写入磁盘

  • 稀疏数组转成原始的二维数组

    • 从磁盘中读取到稀疏数组，根据第一行的数据，创建原始的二维数组 如上图 int [15] [15]
    • 在读取稀疏数组中剩余几行的数据，赋给二维数组即可

1.4 稀疏数组代码实现

1.4.1 创建二维数组并赋予初始值

/**
     * 二维数组初始化
     *
     * <p>
     *     这里模拟定义一个15*15的五子棋棋盘，并已知棋盘中已存在两个棋子
     *     来创建一个[15][15]的二维数组
     * </p>
     * @param
     * @return int[][]
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 15:22 2022/4/15
     **/
    public static int[][] twoDimensionalGoBang() {
        int goBang[][] = new int[15][15];
        goBang[3][3] = 1;
        goBang[4][4] = 2;
        return goBang;
    }

1.4.2 将原有的二维数组转化为稀疏数组

/**
     * 二维数组转成稀疏数组
     *
     * <p>
     *     1.首先遍历原有的二维数组，得知原二维数组有效数据的总个数
     *     2.根据得知的有效数据来创建稀疏数组 [有效数据+1]
     *     3.将二维数据中有效数据的位置和值放到稀疏数组中
     * </p>
     * @param
     * @return int[][]
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 15:37 2022/4/15
     **/
    public static int[][] twoDimensionalToSparse() {
        //创建一个原始的二位数组
        int[][] goBang = twoDimensionalGoBang();
        //1.遍历原有的二维数组，得知有效数据数据的总个数
        int valid = 0;
        for (int i = 0; i < goBang.length; i++) {
            for (int j = 0; j < goBang.length; j++) {
                if (goBang[i][j] != 0) {
                    valid++;
                }
            }
        }
        //2.根据有效数据来创建稀疏数组
        int[][] sparse = new int[valid + 1][valid + 1];
        sparse[0][0] = goBang.length;
        sparse[0][1] = goBang.length;
        sparse[0][2] = valid;
        int count = 0;
        for (int i = 0; i < goBang.length; i++) {
            for (int j = 0; j < goBang.length; j++) {
                if (goBang[i][j] != 0) {
                    count++;
                    sparse[count][0] = i;
                    sparse[count][1] = j;
                    sparse[count][2] = goBang[i][j];
                }
            }
        }
        return sparse;
    }

1.4.3 将稀疏数组转化为原来的二维数组

	public static void main(String[] args) {
        /**
         * <p>
         *     1.根据稀疏数组的特性已知其第一行存放为 二维数组的 行、列、值
         *     2.除第一行以外的数据其余存放的则是有效数据的 行、列、值
         * </p>
         */
        int[][] sparse = twoDimensionalToSparse();
        int[][] two = new int[sparse[0][0]][sparse[0][1]];
        for (int i = 1; i < sparse.length; i++) {
            //稀疏数组的第i行第0,1列为二维数组所在的位置 稀疏数组的第2列则为二维数组的值
            two[sparse[i][0]][sparse[i][1]] = sparse[i][2];
        }
        traverse(two);
    }

1.4.4 遍历二维数组

/**
     * 二维数组遍历
     *
     * @param array 二维数组
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 15:22 2022/4/15
     **/
    public static void traverse(int[][] array) {
        for (int[] row : array) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }

2 队列

  • 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

在这里插入图片描述

2.1 队列的应用场景

  • 如：银行存款取款等、医院的叫号等都算是队列

2.2 队列的基本介绍

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

2.3 单向队列模拟实现

2.3.1 使用数组来模拟实现队列

public class ArrayImitateQueue {
    /**
     * 数组最大容量
     */
    private int maxSize;
    /**
     * 队列头
     */
    private int front;
    /**
     * 队列尾
     */
    private int rear;
    /**
     * 存放数据
     */
    private int[] arr;

    public ArrayImitateQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        //指向队列头的前一个位置
        front = -1;
        //指向队列尾
        rear = -1;
    }

    /**
     * 判断队列是否已满
     *
     * @param
     * @return boolean
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:43 2022/4/15
     **/
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    /**
     * 判断队列是否为空
     *
     * @param
     * @return boolean
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:44 2022/4/15
     **/
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 向队列中添加数据
     *
     * @param num
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:46 2022/4/15
     **/
    public void addQueue(int num) {
        if (isFull()) {
            System.err.println("队列已满不能添加数据");
            return;
        }
        rear++;
        arr[rear] = num;
    }

    /**
     * 取出队列中的值
     *
     * @param
     * @return int
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:50 2022/4/15
     **/
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("ERROR:index out of bounds");
        }
        front++;
        return arr[front];
    }

    /**
     * 显示队列中全部内容
     *
     * @param
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:50 2022/4/15
     **/
    public void showQueue() {
        if (isEmpty()) {
            System.err.println("Queue is Null~");
            return;
        }
        for (int i : arr) {
            System.out.println(i);
        }
    }

    /**
     * 获取队列的头数据
     *
     * @param
     * @return int
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 16:52 2022/4/15
     **/
    public int getFirstQueue() {
        if (isEmpty()) {
            throw new RuntimeException("ERROR:index out of bounds");
        }
        return arr[front + 1];
    }
}

2.3.2 使用链表来模拟实现队列

public class ChainImitateQueue<T> {
    private Node first;
    private Node last;
    private int n;

    /**
     * 在链表中添加数据
     *
     * @param item
     * @return void
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 17:09 2022/4/15
     **/
    public void addQueue(T item) {
        //在链表尾部插入结点
        Node oldLast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        if (isEmpty()) {
            //队列插入第一个元素
            first = last;
        } else {
            oldLast.next = last;
        }
        n++;
    }

    /**
     * 删除链表中的头数据
     *
     * @param
     * @return T
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 17:10 2022/4/15
     **/
    public T removeQueue() {
        //在链表表头删除结点，（对单链表而言,不好删除表尾结点）
        if (isEmpty()) {
            //删除队列中最后一个元素
            throw new RuntimeException("ERROR: There is no more data in the queue to delete");
        }
        T item = first.item;
        first = first.next;
        n--;
        return item;
    }

    /**
     * 判断列表是否为空
     *
     * @param
     * @return boolean
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 17:10 2022/4/15
     **/
    public boolean isEmpty() {
        return n == 0 ? true : false;
    }

    /**
     * 获取列表的长度
     *
     * @param
     * @return int
     * @author ZhangSan_Plus
     * @description //TODO
     * @date 17:11 2022/4/15
     **/
    public int size() {
        return n;
    }


    class Node {
        Node next;
        T item;
    }

    public static void main(String[] args) {
        ChainImitateQueue<Integer> queue = new ChainImitateQueue<>();
        queue.addQueue(10);
        queue.addQueue(100);
        System.out.println(queue.size());
        System.out.println(queue.removeQueue());
        System.out.println(queue.removeQueue());
        System.out.println(queue.size());
        System.out.println(queue.removeQueue());
    }
}

2.3.3 单向队列存在的问题

  • 因为采用rear=maxSize-1 作为队列已满的条件缺陷，当队列条件为真时，队中可能还有若干空位置 队列中明明还有空位置为何不能进入
  • 这种溢出并不是真正的溢出，称为假溢出
  • 从而引出环形队列

2.4 环形队列模拟实现

2.4.1 环形队列基本介绍

  • 因为单向队列存在假溢出的缺陷，从而引入环形队列。
  • 采用把数组的前端和后端连接起来，形成一个环形的顺序表，即把存储队列元素的表从逻辑上看成一个环，称为环形队列或循环队列。
  • 它是一个首尾相连的FIFO的数据结构，采用数组的线性空间,数据组织简单。能很快知道队列是否满为空。能以很快速度的来存取数据

在这里插入图片描述

2.4.2 环形队列设计思路

  • 实际上内存地址一定是连续的，不可能是环形的，通常采用逻辑的方式来实现环形队列，将rear++ 改为( rear=(rear+1)%maxSize) 和 front++ 改为( front=(front+1)%maxSize)
    在这里插入图片描述
  • 队空条件：front=rear
  • 队满条件：(rear+1)%maxSize=front
  • 进队操作：rear=(rear+1)%maxSize; 将进队放在rear处
  • 出队操作：front=(front+1)%maxSize; 取出front处的元素

2.4.3 环形队列数组实现

public class RingImitateQueue {
    /**
     * 数组最大容量
     */
    private int maxSize;
    /**
     * 队列头 初始值=0
     */
    private int front;
    /**
     * 队列尾 rear=0
     */
    private int rear;
    /**
     * 存放数据
     */
    private int[] arr;

    public RingImitateQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
    }

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

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

    public void addQueue(int num) {
        if (isFull()) {
            throw new RuntimeException("队列已满");
        }
        arr[rear] = num;
        //将rear后移
        rear = (rear + 1) % maxSize;
    }

    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        //front指向队列的第一个元素
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    public void showQueue() {
        if (isEmpty()) {
            System.err.println("Queue is Null~");
            return;
        }
        for (int i = 0; i < front + site(); i++) {
            System.out.println(arr[i % maxSize]);
        }
    }

    public int site() {
        return (rear + maxSize - front) % maxSize;
    }
    public int getFirstQueue() {
        if (isEmpty()) {
            throw new RuntimeException("ERROR:index out of bounds");
        }
        return arr[front];
    }
}
张三博客
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
博客
Mysql中Explain详解及索引的最佳实践
03-08 1049
使用关键字可以模拟优化器执行SQL语句，分析查询语句在 SELECT 语句之前增加 explain 关键字，MySQL 会在查询上设置一个标记，执行查询会返回执行计划的信息，而不是执行这条SQL。
博客
OpenFeign和feign使用简介
05-19 1万+
1.可插拔的注解支持，包括Feign注解和JAX-RS注解。2.支持可插拔的HTTP编码器和解码器（Gson，Jackson，Sax，JAXB，JAX-RS，SOAP）。3.支持Hystrix和它的Fallback。4.支持Ribbon的负载均衡。5.支持HTTP请求和响应的压缩。6.灵活的配置：基于 name 粒度进行配置7.支持多种客户端：JDK URLConnection、apache httpclient、okhttp，ribbon）8.支持日志9.支持错误重试10.url支持占位
博客
每天一个面试题-==和equals比较
03-31 522
equals：Object中默认也是采用==比较，通常会重写。
博客
详解Mysql事务隔离级别与锁机制
03-28 880
举例：两个事务同时对库存进行操作 假定该库存初始值为20 A事务将库存更新为15 而B事务则将库存更新为10 就出现了脏写的问题。
博客
Mysql规范篇解读与案例-阿里巴巴开发手册（泰山版）
03-23 1269
必须使用小写字母或数字，禁止出现数字开头，禁止两个下划线中间只出现数字- 数据库字段名更改代价很大 可能改一个字段名就要修改整个业务线- mysql windows 不区分大小写 但在liunx中是区分大小写的
博客
Mysql索引优化实战（分页、JOIN、Count）
03-21 1206
表示从表 employees 中取出从 10001 行开始的 10 行记录, 看着只有10条记录其实是先查询出10010条记录 然后抛弃前10000条记录 数据量越大效率越低。把驱动表的数据读入到 join_buffer 中，然后扫描被驱动表，把被驱动表每一行取出来跟 join_buffer 中的数据做对比。
博客
深入理解Mysql索引底层数据结构与算法
03-07 685
二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。
博客
Java工具类-随机字符串工具类
10-24 802
【代码】Java工具类-随机字符串工具类。
博客
Java中常用的JSON库，哪个性能更牛逼？
10-24 358
字符串解析成JSON性能字符串解析成JavaBean性能JavaBean构造JSON性能集合构造JSON性能易用性。
博客
设计模式-原型模式的应用场景及Java中对抽象工厂的应用
10-19 477
原型模式也称为克隆模式，即某个对象为原型克隆出来一个一模一样的对象，该对象的属性和原型对象一模一样。而且对于原型对象没有任何影响。原型模式克隆的方法有两种：浅克隆和深度克隆
博客
Exception in thread “main“ java.lang.CloneNotSupportedException 解决方案
10-19 682
实现Cloneable。
博客
接入Apple 登录(AuthenticationServices) 后端处理Java版
10-13 1235
【代码】接入Apple 登录(AuthenticationServices) 后端处理Java版。
博客
Java 中的 BigDecimal-那些你不知道的用法
10-03 219
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。
博客
Mysql 基础语法-每个程序员都要掌握的基础知识要点
10-02 683
作为一个程序员必须要会的技能SQL语句，能写一手好的SQL能够让你在人群中出彩。找工作必问SQL关键字、复杂查询、SQL优化你真的都会吗？
博客
Mybatis 升级版开发神器：Fast MyBatis，太强了！
10-01 252
开源地址：https://gitee.com/durcframework/fastmybatis相关文档：https://durcframework.gitee.io/fastmybatis/#/fastmybatis 是一个 mybatis 开发框架，其宗旨为：简单、快速、有效。零配置快速上手，无需编写 xml 文件即可完成 CRUD 操作。同时支持 mysql、sqlserver、oracle、postgresql、sqlite。
博客
火爆全网的“羊了个羊”,疯狂圈钱2400多万,背后隐藏着什么?
09-29 1101
羊了个羊》采用了全网最简单的三消类游戏，这个游戏的难度可谓是有名的小，无论是几岁的孩童还是年过古稀的老人其实都能玩，在这样的情况下，《羊了个羊》就实现了低门槛的布局，再加上用小程序进入，完全不需要任何安装，任何人都能玩的游戏自然而然就能吸引最广大的用户群体，实现病毒式传播的第一轮布局。下面的卡槽位还是7个，可上面的牌型却达到了14种（也有说13种，15种的，反正很多），但是每局都是随机的，所以每个玩家牌面都不太一样，但卡牌的种类至少也在10种以上，而卡牌的总数也呈几何倍数增加，堆叠层数更是达到了几十层。
博客
@Component注解的使用及解析
09-28 7177
@Component 可作用于类、接口、枚举类型等 (Target)@Component 生命周期为运行时 (Retention)@Component 可以使用JavaDoc命令生成文档后查看说明 (Documented)@Component 该类会存储到 META-INF/spring.components (Indexed)
博客
Java获取完整SSL证书链信息(包含完整证书链)
09-16 2万+
Java通过X509获取完整证书链信息包含受信任的和不受信任的证书，包含完整的证书使用者、签发者、签名算法公钥、证书版本、证书品牌等信息
博客
Apache ShardingSphere介绍和基本使用及分库分表(水平拆分、垂直拆分)理解和使用
07-18 2401
分库从单个数据库拆分成多个数据库的过程，将数据散落在多个数据库中。分表从单张表拆分成多张表的过程，将数据散落在多张表内。
博客
java.lang.ClassNotFoundException: com.fasterxml.jackson.annotation.JsonIncludeProperties 异常解决方案
06-30 4036
引入一下三个依赖

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值