稀疏数组和队列

最新推荐文章于 2024-06-01 23:14:10 发布
最新推荐文章于 2024-06-01 23:14:10 发布
阅读量52 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyk112233/article/details/128999612
版权

一、稀疏 sparsearray 数组

先看一个实际的需求

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

稀疏数组的处理方法是:

1) 记录数组一共有几行几列，有多少个不同的值

2) 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

举个栗子：

具体实现：

package com.atguigu.sparsearray;

public class MySparseArray {
    
    public static void main(String[] args) {
        //创建一个原始的二维数组11*11
        //0：表示没有棋子，1表示黑子  2表示篮子
        int[][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        //输出原始的二维数组
        for(int i = 0;i < arr.length;i++) {
            for(int j = 0;j < arr[i].length;j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
        
        //将二维数组转稀疏数组
        //1.先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for(int i = 0;i < arr.length;i++) {
            for(int j = 0;j < arr[i].length;j++) {
                if(arr[i][j] != 0) {
                    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;//用于记录是第几个非0数据
        for(int i = 0;i < arr.length;i++) {
            for(int j = 0;j < arr[i].length;j++) {
                if(arr[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arr[i][j];
                }
            }
        }    
        
        System.out.println("得到的稀疏数组为....");
        //    输出稀疏数组的形式
        for(int i = 0;i < sparseArr.length;i++) {
            for(int j = 0;j < sparseArr[i].length;j++) {
                System.out.printf("%d\t",sparseArr[i][j]);
            }
            System.out.println();
        }
        
        //将稀疏数组-->原始的二维数组
        //1.先读取稀疏数组的第一行，根据第一行的数据创建原始的二维数组
        int arr1[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        
        //2.先读取稀疏数组后几行的数据，并赋给原始的二维数组即可
        
        for (int i = 1; i < sparseArr.length; i++) {
            arr1[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        
        System.out.println();
        System.out.println("恢复后的二维数组");
        for(int[] row : arr1 ) {
            for(int data : row) {
                System.out.printf("%d ",data);
            }
            System.out.println();
        }
        
        
    }
}

二、队列

1) 队列是一个有序列表，可以用数组或是链表来实现。

2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出

数组模拟队列思路

> 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 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;

public 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 'a':
                System.out.println("输入一个数");
                int value = scanner.nextInt();
                queue.addQueue(value);
                break;
            case 'g':
                try {
                    int res = queue.getQueue();
                    System.out.printf("取出数据是%d",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("程序退出");
        
    }
}

//使用数组模拟队列-编写一个ArrayQueue类
class ArrayQueue{
    private int maxSize;//表示数组最大的容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//该数据用于存放数据，模拟队列
    
    //创建队列的构造器
    public ArrayQueue(int arrMaxSize) {
        this.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) 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定,这个在做判断队列满的

时候需要注意 (rear + 1) % maxSize == front [满]

2) rear == front [空]

3) 分析示意图:

package com.atguigu.queue;

import java.util.Scanner;
public class CircleArrayQueueDemo {
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];
}
}
wyyyyyk
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-稀疏数组和队列
skycanf的博客
04-08 149
一、稀疏 sparsearray 数组 1、先看一个实际的需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题: 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数组。 2、基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同值的...
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
04-18
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
利用C++实现以下经典数据结构算法：线性表、栈、队列、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法）、树.zip
12-28
利用C++实现以下经典数据结构与算法：线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法...
数据结构的程序大全（队列、二叉树、数组、图、稀疏矩阵、线性表和链表、栈）
07-12
包括数据结构课程的各种程序：队列、二叉树、数组、图、稀疏矩阵、线性表和链表、栈
稀疏矩阵c++实现
03-14
本代码是系数矩阵的c++实现，在数据结构中，有很多的数据结构，比如树，栈，队列，图，数组，链表等，而矩阵就是其中的一个简单应用。
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 310
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 380
动态规划理论基础（主要就是确定动态规划的几个步骤）
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1181
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 539
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 721
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
图形学初识--空间变换
航行的土豆的博客
05-29 876
介绍二维和三维下的变换矩阵以及常见的推导和理解方式。主要就是：平移、旋转、缩放
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 948
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
24.5.26（树链剖分板子，二分+线段树）
breath_of_yuan的博客
05-27 858
思路：可看出峰值的数量是固定的，为 n/2-1，头尾不可为峰，连续俩数不能都为峰，假如我们让奇数位置的值为峰( 除了头，发现如果p的 n值在偶数位，且挨着1，是无法实现的，但其实也不难解决，将p翻转后 n下标的奇偶性就会改变( 最后输出前记得翻转 q。如果只有偶数子节点，那么0/1的选择是固定的，如果存在奇节点，所有偶节点可以取更大值，对于奇节点的选择，如果偶数个奇节点，0/1各一半，如果奇数个，多的那个取父节点的反，将奇点的 0/1 差值排个序，贪心即可。easy线段树题 建平台。补重庆科技 C 二分。
代码随想录算法训练营第三十六 | ● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间
最新发布
cir_sky的博客
06-01 368
贪心算法——区间问题
分析和设计算法
日积月累
05-29 294
分析和设计算法
大气污染溯源算法及其技术实现
weixin_42496466的博客
05-29 1236
高斯分布由均值（μ）、方差（σ²）决定，公式为: [ f(x)=\frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}]在环境模型中，高斯分布用来描述污染物浓度的概率分布，即在某一特定点的污染物浓度值的概率，随着距离污染源的距离增加而按高斯分布规律衰减小。相关性分析是统计学中一种重要的方法，用于研究两个或多个变量之间相互关系的性质，主要包括关系的方向（正相关或负相关）、强度以及是否存在线性。•偏相关：控制其他变量影响，分析两变量间净相关。
偏微分方程算法之抛物型方程差分格式编程示例一
L_peanut的博客
05-27 248
主要对本专栏所介绍的抛物型偏微分方程的差分格式进行算例补充。
邻接矩阵和优先队列的区别
03-10
邻接矩阵和优先队列是在不同领域中使用的数据结构，它们的主要区别如下： 邻接矩阵： - 邻接矩阵是一种用于表示图的数据结构，特别适用于稠密图（边数接近于顶点数的平方）。 - 它使用一个二维数组来表示图中的顶点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wyyyyyk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值