第 3 章：稀疏数组和队列

最新推荐文章于 2022-04-08 22:30:07 发布
最新推荐文章于 2022-04-08 22:30:07 发布
阅读量308 收藏
点赞数
分类专栏： 老韩数据结构
原文链接：https://blog.csdn.net/prefect_start/article/details/115642948
版权

第 3 章：稀疏数组和队列

文章目录

1、稀疏数组

1.1、实际需求

  • 编写的五子棋程序中，有存盘退出和续上盘的功能
  • 因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储
    在这里插入图片描述

1.2、稀疏数组应用

  • 1.2.1、稀疏数组处理方法
  • 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
    稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列
  • 稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值
    • 第一列：原数组的行数
    • 第二列：原数组的列数
    • 第三列：原数组有多少个不为零的值
      之后的行记录原数组中不为零（x）的值所在的行数、列数以及 x 的值
    • 第一列：x 在原数组中的行数
    • 第二列：x 在原数组中的列数
    • 第三列：x 的值

1.2.2、举例说明

  • 原始二维数组较大，压缩后占用空间减少
    在这里插入图片描述

1.3、应用实例

  • 1.3.1、思路分析
  • 使用稀疏数组， 来保留类似前面的二维数组(棋盘、 地图等等)
  • 把稀疏数组存盘， 并且可以从新恢复原来的二维数组数

在这里插入图片描述

  • 1.3.2、代码实现

  • 代码

package ArrayAndQueue;

import java.io.*;
import java.util.Arrays;

//  原始二维数组--》稀疏数组--》还原为原始数组
public class arr01 {
    public static void main(String[] args) {
        //1. 创建一个原始的二维数组 8*9
        // 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
        int[][] oriArr = new int[6][9];
        oriArr[1][2] = 1;
        oriArr[1][5] = 1;
        oriArr[4][2] = 2;
        oriArr[5][3] = 2;
        //打印原始数组
        System.out.println("原始数组开始~~");
        for (int i = 0; i < oriArr.length; i++) {
            for (int j = 0; j < oriArr[0].length; j++) {
                System.out.print(oriArr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("原始数组完毕~~");

        //2. 创建稀疏数组
        //遍历原始数组，记录非0数据个数
        int cnt = 0;
        for (int i = 0; i < oriArr.length; i++) {
            for (int j = 0; j < oriArr[0].length; j++) {
                if (oriArr[i][j] != 0)
                    cnt++;
            }
        }
        int[][] spareArr = new int[cnt + 1][3];
        int k = 0;
        spareArr[k][0] = oriArr.length;
        spareArr[k][1] = oriArr[0].length;
        spareArr[k][2] = cnt;
        k++;

        //3. 为稀疏数组赋值
        for (int i = 0; i < oriArr.length; i++) {
            for (int j = 0; j < oriArr[0].length; j++) {
                if (oriArr[i][j] != 0) {
                    spareArr[k][0] = i;
                    spareArr[k][1] = j;
                    spareArr[k][2] = oriArr[i][j];
                    k++;
                }
            }
        }
        //打印稀疏数组
        System.out.println("稀疏数组开始~~");
        for (int i = 0; i < spareArr.length; i++) {
            for (int j = 0; j < spareArr[0].length; j++) {
                System.out.print(spareArr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("稀疏数组结束~~");

        //4.1将稀疏数组保存到磁盘
        File file = null;
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        try {
            System.out.println("创建文件，开始保存到磁盘：");
            file = new File("map.data");
            fos = new FileOutputStream(file);
            osw = new OutputStreamWriter(fos);
            System.out.println("写入中...");
            for (int i = 0; i < spareArr.length; i++) {
                osw.write(spareArr[i][0] + " " + spareArr[i][1] + " " + spareArr[i][2]+" ");
            }
            System.out.println("保存成功！");
            osw.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }

        //4.2读取稀疏数组到内存
        FileInputStream fis = null;
        byte[] b;
        StringBuffer sb;
        String[] split = null;
        //创建一个新的稀疏数组
        int[][] spareArr2 = null;
        try {            
        	System.out.println("读取存盘...");
            fis = new FileInputStream(file);
            int i;
            sb = new StringBuffer();
            b = new byte[2]; //容器：装载读取到的字节流
            while ((i = fis.read(b)) != -1) {
                sb.append(new String(b, 0, i));
            }
            split = sb.toString().split(" ");
            System.out.println(Arrays.toString(split));

            //为新的稀疏数组赋值
            spareArr2 = new int[split.length/3][3];
            for (int j = 0; j < split.length; j++) {
                spareArr2[j / 3][j % 3] = Integer.parseInt(split[j]);
            }
            System.out.println("读取完成！");


            System.out.println("恢复的稀疏数组开始~~");
            for (int m = 0; m < spareArr2.length; m++) {
                for (int n = 0; n < spareArr2[0].length; n++) {
                    System.out.print(spareArr2[m][n] + "\t");
                }
                System.out.println();
            }
            System.out.println("恢复的稀疏数组结束~~");
        } catch (Exception e) {
            e.printStackTrace();
        }

        //5.恢复原数组
        //创建恢复数组
        int[][] revcArr = new int[spareArr[0][0]][spareArr[0][1]];
        //为回复数组赋值
        for (int i = 1; i < spareArr2.length; i++) {
            revcArr[spareArr2[i][0]][spareArr2[i][1]] = spareArr2[i][2];
        }
        //打印恢复数组
        System.out.println("恢复数组开始~~");
        for (int i = 0; i < revcArr.length; i++) {
            for (int j = 0; j < revcArr[0].length; j++) {
                System.out.print(revcArr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("恢复数组结束~~");

    }
}
  • 结果
原始数组开始~~
0	0	0	0	0	0	0	0	0	
0	0	1	0	0	1	0	0	0	
0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	
0	0	2	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	
原始数组完毕~~
稀疏数组开始~~
6	9	4	
1	2	1	
1	5	1	
4	2	2	
5	3	2	
稀疏数组结束~~
创建文件，开始保存到磁盘：
写入中...
保存成功！
读取存盘...
[6, 9, 4, 1, 2, 1, 1, 5, 1, 4, 2, 2, 5, 3, 2]
读取完成！
恢复的稀疏数组开始~~
6	9	4	
1	2	1	
1	5	1	
4	2	2	
5	3	2	
恢复的稀疏数组结束~~
恢复数组开始~~
0	0	0	0	0	0	0	0	0	
0	0	1	0	0	1	0	0	0	
0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	
0	0	2	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	
恢复数组结束~~

1.4、课后练习

  • 在前面的基础上， 将稀疏数组保存到磁盘上， 比如 map.data
  • 恢复原来的数组时， 读取 map.data 进行恢复
  • 代码见上述，主要运用读入读出流。

2、队列

2.1、队列使用场景

银行排队的案例：

2.2、队列介绍

  • 队列是一个有序列表， 可以用数组或是链表来实现。
  • 遵循先入先出的原则， 即： 先存入队列的数据， 要先取出，后存入的要后取出
  • 示意图： (使用数组模拟队列示意图)
    在这里插入图片描述

2.3、数组模拟队列

  • 2.3.1、思路分析

    • maxSize ：队列容量（数组的长度）
    • arr ：模拟队列的数组
    • front ：指向队列头部元素的前一个元素，初始值为 -1
    • rear ：指向队列尾部元素，初始值为 -1

在这里插入图片描述

  • 基本操作
    队列判空：front == rear
    队列判满：rear == (maxSize - 1) ，即 rear 是否已经指向了数组的最后一个位置
    队列元素个数：rear - front
    队列入队：队列不满才能入队，arr[++rear] = value
    队列出队：队列不空才能出队，return arr[front++]

  • 2.3.2 代码实现

2.4、数组模型环形队列

  • 2.4.1、提出问题
    目前数组使用一次就不能用， 没有达到复用的效果，造成内存空间的浪费
    将这个数组使用算法， 改进成一个环形的队列（取模： %）
  • 2.4.2、思路分析
    对前面的队列进行优化，改造为环形队列（通过取模实现）
    maxSize ：队列容量（数组的长度）
    arr ：模拟队列的数组
    front ：指向队列头部元素，初始值为 0
    rear ：指向队列尾部元素的后一个元素，初始值为 0

在这里插入图片描述

  • 基本操作

    • 队列判空：front == rear
    • 队列判满：
      • 为何要在 rear 之后，front 之前空出一个元素的空间？因为如果不空出一个元素，队列判空条件为：front == rear ，队列判满的条件也是：front == rear ，有歧义！
    • 队列容量：因为空出了一个元素，所以队列容量就变成了 (maxSize - 1)
      • 当空出一个元素的空间，如何判满？当还剩一个元素时，队列就已经满了，所以判断条件为 (rear + 1) % maxSize == front
    • 队列元数个数：
      • 计算公式：(rear + maxSize - front) % maxSize ，这样来思考：
      • 当 rear 比 front 大时，即 (rear -front) > 0 ，这时还没有形成环形结构，(rear -front) 即是队列元素个数
      • 当 rear 比 front 小时，即 (rear -front) < 0 ，这时已经形成了环形结构，(rear -front) 表示数组还差多少个元素存满（负数），(rear + maxSize - front) 即是队列元素个数
      • 综上：(rear + maxSize - front) % maxSize
    • 队列入队：
      • 首先，队列不满才能入队
      • 由于 rear 指向队列尾部元素的后一个元素，所以直接设置即可： arr[rear] = value
      • 接下来，rear 应该向后移动一个位置：rear = (rear + 1) % maxSize
      • 取模是为了防止数组越界，让指针从新回到数组第一个元素
    • 队列出队：
      • 首先，队列不空才能出队
      • 由于 front 直接指向队列头部元素，所以直接返回该元素即可：int value = arr[front ]
      • 接下来，front 应该向后移动一个位置：front = (front + 1) % maxSize
        取模是为了防止数组越界，让指针从新回到数组第一个元素

  • 2.4.3、代码实现

    • 环形队列的实现
哒哒-哒-哒哒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研系列-数据结构第三章：栈、队列和数组
Nelson_hehe的博客
06-12 1812
本文详细总结了王道考研视频课内关于栈、队列的结构、常用操作以及应用场景，还对二维矩阵中特殊矩阵的压缩存储进行总结归纳。文章中还整理了常见的错题和知识归纳总结，是考研复习的好帮手！
第三章：栈和队列
m0_63027727的博客
11-17 238
第三章：栈和队列 一、栈 1.栈的定义 栈（Stack）—是只允许在一端进行插入或删除操作的线性表。 （特性：后进先出） 空栈—栈中没有任何数据元素。 栈顶—允许插入和删除的一端。 栈底—不允许插入和删除的一端。 2.栈的基本操作 栈的基本操作和线性表基本操作类似。（创、销、增、删、查） InitStack(&S)：初始化栈。构造一个空栈S，分配内存空间。 DestroyStack(&S)：销毁栈。销毁并释放栈S所占用的内存空间。 Push(&S,x)：进栈，若栈S未满，则将x加入使
用数组实现环形队列（尚硅谷Java数据结构与算法）
ALi的博客
09-12 547
整个代码在文章最后面，gitee地址：java数据结构与算法: 自己学习与练习数据结构的仓库https://gitee.com/ALi_L/javaDataStructurs.git 环形队列的难点如下： 1.如何判断队列已经满了 2.如何判断队列是空的 3.如何打印队列 4.如何增加一个元素到队列 解决方法： 首先用front指向队列的首元素地址，用rear指向队列最后一个元素后面的地址，队列的属性如下：。 private int maxSize; private int
数组实现环形队列
weixin_42345223的博客
10-02 133
import java.util.Scanner; /** * */ public class RingQueue<T> { public static void main(String[] args) { RingQueue<Integer> integerRingQueue = new RingQueue<Integer>(3); Scanner scanner = new Scanner(System.in); .
用数组实现环形队列
CSRAWD的博客
02-01 428
看了尚硅谷数据结构与算法的视频，跟着写了一个使用数组来实现环形队列的代码，插个眼记录一下。 就这个实现而言，主要需要注意的是：头指针、尾指针循环时采取的“取模”操作，以及存在一个数组元素空间的预留 这个实现，其实有很多种方法，这只是其中一种 代码如下： class CircleArray{ private int maxSize; //数组的最大容量 private int front; ...
通过数组实现的环形队列
qq_44287198的博客
05-07 516
环形队列通过数组实现的环形队列队列操作图解（1）判断是否为空（2）判断队列是否满（3）添加操作（4）取出操作队列代码实现原理讲解 通过数组实现的环形队列 通过数组实现的队列可以分为两种: 1.一种是取出后数组空间不可用的顺序队列。也就是普通队列，这种队列最大的好处就是实现简单,但取出后空间不可使用 2.另一种就是接下来我要说的环形队列，它通过改变队尾指向，将满队列队尾指向队首来实现循环队列 队列 队列是一种特殊的线性表,它通过表前端(front)进行删除操作,通过表后端（rear）进行插入操作，和栈一样，队
数据结构：第五章 数组和广义表.ppt
06-10
第五章“数组和广义表”主要探讨两种重要的线性数据结构的扩展形式：数组和广义表。 线性表是最基本的数据结构之一，它由相同类型的数据元素构成的有限序列组成。线性表的特点是元素之间存在一对一的线性关系，即每...
数据结构第五章：数组和广义表
欢迎来到关关雎鸠儿的博客
08-30 5911
之前的线性结构的数据构成特点： 线性表的数据构成：原子类型数据对象 栈和队列的数据构成：原子类型的数据对象 串的数据构成：字符 实际上，线性结构可以包含更广泛的数据类型： 可以是原子类型的数据对象； 可以是结构类型的数据对象； 可以是混合类型的数据—广义表 1 数组的类型定义 1．一维数组 一维数组可看成是一个线性表或一个向量，存储在一块连续的存储单元中，适合于随机查找。一维数组记为A[n...
第五章 数组和广义表(1).pdf
09-30
第五章数组和广义表主要讲述了数组和广义表的概念、特点、存储结构以及基本操作方法。在数组的讲解中，它首先强调了数组与线性表的差异。线性表、栈、队列、串等数据结构中，每个元素的类型必须相同，称为数据类型...
第二章、数组实现环形队列
prefect_start的博客
04-12 279
1、数组实现队列 1.1、队列介绍 队列是一个有序列表， 可以用数组或是链表来实现。遵循先入先出的原则， 即： 先存入队列的数据， 要先取出，后存入的要后取出。 1.2、队列使用场景 银行排队叫号 1.3、使用数组模拟队列示意图 1.4、思路分析 maxSize ：队列容量（数组的长度） arr ：模拟队列的数组 front ：指向队列头部元素，初始值为 0 rear ：指向队列尾部元素的后一个元素，初始值为 0 1.5、常用方法 队列判空：front == rear 队列判满： 为何要在 re
使用数组实现环形队列
weixin_45676310的博客
03-22 148
使用数组实现环形队列 class CircleQueue{ private int maxSize; private int front;//0 private int rear;//0 private int arr[]; public CircleQueue(int maxSize) { this.maxSize = maxSize+1;//因为空出来一个，所以环形队列容量比...
环形数组实现队列
xiaoxiaoxiaopb的博客
09-07 468
文章目录前言一、队列二、环形数组实现队列总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 一、队列           队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 二、环形数组实现队列 &nbs
数组模拟环形队列实现
梦里花落知多少的博客
07-19 481
环形队列介绍 环形队列是一种头尾相连的结构，可以用数据或者链表来实现，本文通过数组实现。 1.队列的基本特性是先进先出，所以添加元素时尾部指针往后移，获取元素时，从队列头获取。 2.队列为空时，头尾指针都为0 添加元素时指针变化 add(1) tail 0 -> 1 head 0 add(2) tail 1 -> 2 head 0 add(3) tail 2->3 head 0 ··· add(7) tail 6 ->7 head 0 此时队列满 获取元素时指针变化（接上面的数
队列——使用数组实现环形队列（2）
qie ting feng yin的博客
04-08 381
2.2.4 数组模拟环形队列 对前面的数组模拟队列的优化，充分利用数组，因此将数组看作为一个环形的。（通过取模的方式实现即可） 分析说明 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，判断队列满的条件为：（rear+1）%maxSize ==front 表示队列已满 rear == front 表示队列为空 分析示意图： 思路如下： front 变量的含义做一个调整：front 指向队列的第一个元素，也就是说arr[front] 就是队列的第一个元素，f
循环队列
小白鼠丶
08-13 618
对于顺序队列存在的问题，使用循环队列进行解决 数组模拟环形队列 对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方 式来实现即可) 分析说明： 尾索引的下一个为头索引时表示队列满，即将队 列容量空出一个作为约定,这个在做判断队列满的 时候需要注意 (rear + 1) % maxSize == front 满] rear == front [空] 代码...
算法时间复杂度分析：数组与稀疏矩阵乘法优化
在第五章关于数组与广义表的内容中，主要讨论了算法的时间复杂度分析。首先，我们关注的是累加器ctemp初始化的时间复杂度，由于涉及到两个矩阵M和N，其时间复杂度为O(M.mu * N.nu)，这里的mu和nu分别代表矩阵的行数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值