数据结构——稀疏数组和队列

@H³M

已于 2023-06-23 17:00:07 修改

阅读量324

点赞数 1

文章标签：算法

于 2023-06-22 18:20:10 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_55902321/article/details/131314296

版权

文章介绍了如何使用稀疏数组来优化存储大量0值的二维数组，详细阐述了从二维数组转换为稀疏数组以及反向转换的步骤，并提供了Java代码实现。此外，还讲解了队列的概念，包括数组模拟队列的基本思想，以及优化后的环形队列的实现方式。

摘要由CSDN通过智能技术生成

目录

稀疏数组和队列

1、稀疏数组

1.1 先看一个稀疏数组的实际的需求

1.2 稀疏数组的基本介绍

1.3 应用实例

1.4 代码实现

2.1 队列的一个使用场景

2.2 队列介绍

2.3 数组队列模拟队列思路

2.4 数组模拟环形队列

稀疏数组和队列

1、稀疏数组

1.1 先看一个稀疏数组的实际的需求

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

分析问题

因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据，所以可以利用稀疏数组来压缩数组。

1.2 稀疏数组的基本介绍

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

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

稀疏数组的举例说明

1.3 应用实例

使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)。
通过稀疏数组，可以重新恢复原来的二维数组数。
整体思路分析

二维数组转稀疏数组的思路

遍历原始的二维数组，得到有效数据的个数sum。
根据sum就可以创建稀疏数组sparseArr：int[sum+1][3]。
将二维数组中的行数、列数和sum放入到稀疏数组的第一行中。
将二维数组的有效数据存入到稀疏数组。

稀疏数组转二维数组的思路

先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2：int[11][11]。
在读取稀疏数组后几行的数据，并赋给原始的二维数组即可。

1.4 代码实现

package com.itaem;

/**
 * Created with IntelliJ IDEA.
 * @Author: Y.
 * @Date: 2023/06/21/10:33
 * @Description:
 */

public class sparseArray {

    public static void main (String[] args) {
        // 1. 创建二维数组chessArr，并将其输出
        // 0：表示没有棋子，1：表示黑子，2：表示蓝子
        int[][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        for (int[] row : chessArr) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        // 2. 二维数组转稀疏数组
        // 2.1 遍历原始的二维数组，得到有效数据的个数sum。
        int sum = 0;
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[0].length; j++) {
                if (chessArr[i][j] != 0) {
                    sum++;
                }
            }
        }

        // 2.2 根据sum就可以创建稀疏数组sparseArr：int[sum+1][3]。
        int[][] sparseArr = new int[sum+1][3];

        // 2.3 将二维数组中的行数、列数和sum放入到稀疏数组的第一行中。
        sparseArr[0][0] = chessArr.length;
        sparseArr[0][1] = chessArr[0].length;
        sparseArr[0][2] = sum;

        // 2.4 将二维数组的有效数据存入到稀疏数组。
        int num = 0;
        for (int i = 0; i < chessArr.length; i++) {
            for (int j = 0; j < chessArr[0].length; j++) {
                if (chessArr[i][j] != 0) {
                    num++;
                    sparseArr[num][0] = i;
                    sparseArr[num][1] = j;
                    sparseArr[num][2] = chessArr[i][j];
                }
            }
        }

        // 2.5 输出稀疏数组
        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]);
        }

        // 3. 稀疏数组转二维数组
        // 3.1 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的chessArr2：int[11][11]。
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

        // 3.2 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可。
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }

        // 3.3 输出二维数组
        for (int[] row : chessArr2) {
            for (int data : row) {
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    }

}

2、队列

2.1 队列的一个使用场景

银行排队的案例：

2.2 队列介绍

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

2.3 数组队列模拟队列思路

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

当我们将数据存入队列时称为"addQueue"，"addQueue"的处理需要有两个步骤

将尾指针往后移：rear+1，当 front == rear 时队列为空。
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中否则无法存入数据。当 front == maxSize-1时队列为满。

代码实现：

package com.itaem;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * @Author: Y.
 * @Date: 2023/06/22/14:51
 * @Description:
 */

public class ArrayQueueDemo {
    public static void main(String[] args) {
        // 测试
        // 创建一个队列
        ArrayQueue arrayQueue = new ArrayQueue(3);
        // 接受用户输入
        char key = ' ';
        boolean loop = true;
        Scanner sc = new Scanner(System.in);
        // 输出一个菜单
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            System.out.println("e(exit):退出程序");
            //接收一个字符
            key = sc.next().charAt(0);
            switch (key) {
                // 显示队列的所有数据
                case 's' :
                    arrayQueue.showQueue();
                    break;
                // 添加数据到队列
                case 'a' :
                    System.out.print("请输入一个正整数：");
                    int value = sc.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                // 获取队列的数据，出队列
                case 'g' :
                    try {
                        int res = arrayQueue.getQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                // 显示队列的头数据，注意不是取出数据
                case 'h' :
                    try {
                        int res = arrayQueue.headQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                // 退出
                case 'e' :
                    sc.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) {
        maxSize = arrMaxSize;
        // 指向队列头部，分析出front是指向队列头的前一个位置
        front = -1;
        // 指向队列尾部，指向队列尾的数据（即就是队列最后一个数据）
        rear = -1;
        arr = new int[arrMaxSize];
    }

    // 判断队列是否为满
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return front == rear;
    }

    // 添加数据到队列
    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];
    }
}

问题分析并优化

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

2.4 数组模拟环形队列

对前面的数组模拟队列的优化：为了充分利用数组，因此将数组看作是一个环形的。（通过取模的方式来实现即可）
思路如下：

对front变量的含义做一个调整：front指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素；front的初始值=0。
对rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间做为约定；rear的初始值=0。
当队列为满时，条件是：(rear +1) % maxSize == front。
当队列为空时，条件是：rear == front。
队列中有效的数据的个数为 (rear+maxSize-front)%maxSize

代码实现：

package com.itaem.queue;
import java.util.Scanner;
/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Y.
 * @Date: 2023/06/22/17:56
 * @Description:
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        // 测试
        // 创建一个环形队列
        CircleArrayQueue circleArrayQueue = new CircleArrayQueue(4);
        // 接受用户输入
        char key = ' ';
        boolean loop = true;
        Scanner sc = new Scanner(System.in);
        // 输出一个菜单
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            System.out.println("e(exit):退出程序");
            //接收一个字符
            key = sc.next().charAt(0);
            switch (key) {
                // 显示队列的所有数据
                case 's' :
                    circleArrayQueue.showQueue();
                    break;
                // 添加数据到队列
                case 'a' :
                    System.out.print("请输入一个正整数：");
                    int value = sc.nextInt();
                    circleArrayQueue.addQueue(value);
                    break;
                // 获取队列的数据，出队列
                case 'g' :
                    try {
                        int res = circleArrayQueue.getQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                // 显示队列的头数据，注意不是取出数据
                case 'h' :
                    try {
                        int res = circleArrayQueue.headQueue();
                        System.out.println(res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                // 退出
                case 'e' :
                    sc.close();
                    loop = false;
                    break;
                default :
                    break;
            }
        }
        System.out.println("程序结束！");
    }
}

class CircleArrayQueue {
    // 表示数组的最大容量
    private int maxSize;
    // 对front变量的含义做一个调整：front指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素
    // front的初始值=0
    private int front;
    // 对rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间做为约定
    // rear的初始值=0
    private int rear;
    // 该数组用于存储数据，模拟队列
    private int[] arr;

    // 创建队列的构造器
    public CircleArrayQueue (int arrMaxSize) {
        maxSize = arrMaxSize;
        // 默认为0，可以不写
        front = 0;
        // 默认为0，可以不写
        rear = 0;
        arr = new int[arrMaxSize];
    }

    // 判断队列是否为满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return front == rear;
    }

    // 添加数据到队列
    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对应的值保留到一个临时变量
        int value = arr[front];
        // 2. 将front后移，考虑取模
        front = (front + 1) % maxSize;
        // 3. 将临时保存的变量返回
        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(){
        return (rear + maxSize - front) % maxSize;
    }

    // 显示队列的头数据，注意不是取出数据
    public int headQueue() {
        // 判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列为空，不能取数据！");
        }
        return arr[front];
    }
}

@H³M CSDN认证博客专家 CSDN认证企业博客

码龄4年

13: 原创

60万+: 周排名

8万+: 总排名

6839: 访问

: 等级

278: 积分

74: 粉丝

146: 获赞

6: 评论

129: 收藏

私信

关注

热门文章

最新评论

代码随想录——JAVA算法题——数组
CSDN-Ada助手: 推荐 Java 技能树：https://edu.csdn.net/skill/java?utm_source=AI_act_java
数据结构与算法——链表
CSDN-Ada助手: 恭喜您写了第5篇博客！标题“数据结构与算法——链表”真是精彩的选择。您的文章内容非常有趣，让我对链表有了更深入的了解。希望您能继续保持创作的热情，给读者们带来更多有关数据结构与算法的精彩内容。作为下一步的创作建议，或许您可以考虑探索链表的应用场景，或者分享一些优化链表操作的技巧。期待您的下一篇博客！
数据结构与算法——栈
CSDN-Ada助手: 恭喜您写了第6篇博客！标题为“数据结构与算法——栈”的文章看起来很有趣。您的博客内容一直很有深度，非常值得称赞。在下一步的创作中，我建议您可以尝试探索一些与栈相关的实际应用场景，或者深入研究栈的具体实现方式。期待您的新作品，继续保持努力和谦逊的态度！
数据结构与算法——树
CSDN-Ada助手: 非常棒的博客！恭喜您写了第7篇关于数据结构与算法的博客，题目为“树”。您的文章内容深入浅出，对树这一数据结构进行了清晰的解释。我真的非常欣赏您持续创作的努力和热情。在下一步的创作中，我建议您可以尝试探索树在不同应用领域的实际应用，或者深入研究一些树的变种结构，这样可以更加丰富您的博客内容。期待您未来更多的精彩文章！
数据结构——稀疏数组和队列
CSDN-Ada助手: 恭喜用户又发布了一篇关于“尚硅谷——稀疏数组和队列”的博客，很高兴看到您一直在坚持创作。关于下一步的创作建议，或许可以考虑写一些实战案例，让读者更好地理解和应用相关知识。再次感谢您的分享，期待更多精彩内容。 CSDN 会根据你创作的前四篇博客的质量，给予优秀的博主博客红包奖励。请关注 https://bbs.csdn.net/forums/csdnnews?typeId=116148&utm_source=csdn_ai_ada_blog_reply4 看奖励名单。

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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