数组结构与算法-007-015稀疏数组与队列

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量119 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46998705/article/details/107010215
版权

007 稀疏数组的应用场景

基本介绍：
当一个数组中大部分元素为0，或者为同一个数值的数组时，可以稀疏数组来保存该数组

稀疏数组的处理方法是：

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

在这里插入图片描述

008 稀疏数组转换的思路分析

应用实例

  1. 使用稀疏数组，来保留类似前面的二维数组（棋盘、地图等等）
  2. 把稀疏数组存盘，并且可以重新恢复原来的二维数组数
  3. 整体思路分析
    在这里插入图片描述

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

  • 遍历原始的二维数组，得到有效数据的个数 sum
  • 根据 sum 就可以创建稀疏数组 sparseArr in[sum + 2] [3]
  • 将二维数组的有效数据存入到稀疏数组中
    稀疏数组转原始二维数组
  1. 读取稀疏数组的第一行，根据第一行，创建原始的二维数组，比如上面的 chessArr2 = ing[11][11]
  2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组

009 稀疏数组的代码实现

package com.old.sparseArray;

public class SparseArray {
    public static void main(String[] args) {
        //创建一个原始的二维数组 11 * 11
        //0:表示没有苊，1表示白子 2 表示黑子
        int chessArr1[][] = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[4][5] = 1;

        //输出原始的二维数据
        for (int[] row : chessArr1) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //二维数组转稀疏数组
        //1.遍历二维数组得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < chessArr1.length; i++) {
            int[] ints = chessArr1[i];
            for (int j = 0; j < ints.length; j++) {
                if (ints[j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("总数：" + sum);

        //2.创建对应的稀疏数组 sum + 1是因为数组是从0开始，所有需要加1
        int sparseArr[][] = new int[sum + 1][3];
        /**
         * 给稀疏数组赋值 这里为什么这样还未明白
         * 这里是为了记录原始数组的行和列的长度，而最后一个值是用于保存
         * 原始数组的有效值个数
         */
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        //遍历二维数组，将非0的值存放到稀疏数组中
        int count = 0;//用于记录是第几个非0数据
        for (int i = 0; i < chessArr1.length; i++) {
            int[] ints = chessArr1[i];
            for (int j = 0; j < ints.length; j++) {
                if (ints[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.读取稀疏数组的第一行，
        int cheessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
        //输出恢复后的二维数组
        System.out.println();
        //从稀疏数组的第二行开始
        for (int i = 1; i < sparseArr.length; i++) {
            int[] ints = sparseArr[i];
            for (int j = 0; j < ints.length; j++) {
                cheessArr2[ints[0]][ints[1]] = sparseArr[i][2];
            }
        }
        System.out.println("恢复后的原始数组");
        for (int[] row : cheessArr2) {
            for (int data : row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

010 队列的应用场景

队列介绍

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

010 数组模拟队列的思路分析

数组模拟队列

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

011 数组模拟队列

  1. 将数据存入队列时称为 “addQueue” ，addQueue 的处理需要有两个步骤：
  2. 将尾指针往后移： rear + 1 ， 当 front == rear 【空】
  3. 若尾指针 rear 小于队列的最大下标 maxSize - 1 ，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == maxSize -1 【队列满】

012 数组模拟队列代码实现

package com.old.queue;


import java.util.Arrays;
import java.util.Scanner;

public class ArrayQueueDemo {

    public static void main(String[] args) {
    	/**
    	队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。
		一开始创建的头和尾的指针都是-1，
		当添加数据时，队列尾加1
		当输出数据时，队列头加1
		两个属性，front 和 rear 一个代表存到了哪，一个代表取到了哪，如果存和取是等于，代表队列中没有数据,如果 头 大于等于 队列的最大容量，就表示队列已经满了。
		数组是有顺序的，存入的第一个就在数组的 0 下标的位置，存入的第二个就在数组的 1 下标的位置，而加入数据一直对 队列尾属性+1，这样这个属性也代表着数组当前存入的数据的位置。
		取出数据则是对，队列头属性+1，这个属性就代表着当前数组取出数据的位置。
		因为队列只能一边存，一边取，所以存是从队列尾中加入，所以存入就队列尾加1，取出就是队列头加1
		*/
        ArrayQueue arrayQueue = new ArrayQueue(3);
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("1.显示队列");
            System.out.println("2.退出程序");
            System.out.println("3.添加数据到队列");
            System.out.println("4.从队列取出数据");
            System.out.println("5.查看头数据");
            String s = scanner.nextLine();
            try {
                switch (s) {
                    case "1":
                        arrayQueue.showQueue();
                        break;
                    case "2":
                        scanner.close();
                        System.out.println("扫描器已关闭");
                        loop = false;
                        break;
                    case "3":
                        System.out.println("请输入数字：");
                        String value = scanner.nextLine();
                        arrayQueue.addQueue(Integer.valueOf(value));
                        break;
                    case "4":
                        System.out.println("取出：" + arrayQueue.getQueue());
                        break;
                    case "5":
                        System.out.println("取出：" + arrayQueue.headQueue());
                        break;
                }
            } catch (Exception e) {
                               System.out.println(e.getCause());

            }
            System.out.println();
            System.out.println("队列头,fron：" + arrayQueue.getFront());
            System.out.println("队列尾,rear：" + arrayQueue.getRear());
            System.out.println();
        }
    }
}

//使用数组模拟队列
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++;
        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];
    }

    public int getFront() {
        return front;
    }

    public int getRear() {
        return rear;
    }
}

问题分析并优化

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

014 数组模拟环形队列的思路分析

对前面的数组模拟队列的优化，充分利用数组，因此将数组看做是一个环形的。（通过取模的方式来实现）
分析说明：

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意 （rear + 1 ) % maxSize == fron 满
  2. rear == front 空

在这里插入图片描述

015 数组模拟环形队列实现

将数组看做是一个环形。（通过取模的方式来实现）
分析说明：

  1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 即满
  2. rear == front 空
package com.old.queue;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 环形数组队列
 */
public class CircleArrayQueue {
    public static void main(String[] args) {

        CircleArray queue = new CircleArray(3);
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("1.显示队列");
            System.out.println("2.退出程序");
            System.out.println("3.添加数据到队列");
            System.out.println("4.从队列取出数据");
            System.out.println("5.查看头数据");
            String s = scanner.nextLine();
            try {
                switch (s) {
                    case "1":
                        queue.showQueue();
                        break;
                    case "2":
                        scanner.close();
                        System.out.println("扫描器已关闭");
                        loop = false;
                        break;
                    case "3":
                        System.out.println("请输入数字：");
                        String value = scanner.nextLine();
                        queue.addQueue(Integer.valueOf(value));
                        break;
                    case "4":
                        System.out.println("取出：" + queue.getQueue());
                        break;
                    case "5":
                        System.out.println("取出：" + queue.headQueue());
                        break;
                }
            } catch (Exception e) {
                System.out.println(e.getCause());
            }
            System.out.println();
            System.out.println("队列头,fron：" + queue.getFront());
            System.out.println("队列尾,rear：" + queue.getRear());
            System.out.println();
        }
    }
}

//使用数组模拟队列
class CircleArray {
    private int maxSize;//数组最大容量
    /**
     * 队列头
     * front 变量的含义做一个调整：front 就指向队列的第一个元素，也就是说
     * arr[front] front 的初始值 = 0
     */
    private int front;
    /**
     * 队列尾
     * front 变量的含义做一个调整： rear 指向队列的最后一个元素的后一个位置，
     * 因为希望突出一个
     * rear 的初始值 = 0
     */
    private int rear;
    private int[] arr;//该数组用于存放数据，模拟队列


    //创建队列的构造器
    public CircleArray(int arrMaxSize) {
        this.maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = 0;//队列头部，分析出，front 是指向队列头的前一个位置
        rear = 0;//指向队列尾，指向队列尾的数据（即就是队列最后一个数据）
    }

    //判断队列是否满
    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;
        }
        //因为 rear 本身就指向下一个元素，所以直接将数据加入
        arr[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    //获取队列数据 出队列
    public int getQueue() {
        //判断队列是否为空
        if (isEmpty()) {
            throw new RuntimeException("队列中没有数据");
        }

        /**
         * front 本身就指向了队列的第一个元素
         * 1. 先把 front 对应的值保留到一个临时变量
         * 2. 将 front 后移，考虑取模. 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++) {
            int index = i % maxSize;
            System.out.printf("arr[%d]=%d\n", index, arr[index]);
        }

    }

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

    //显示队列的头数据，不是取出数据
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列中没有数据");
        }
        return arr[front];
    }

    public int getFront() {
        return front;
    }

    public int getRear() {
        return rear;
    }
}
1854君
关注
数据结构与算法 -- -- -- 稀疏数组 与 队列
qq_58293159的博客
03-12 1444
2-1稀疏数组sparsearray 2-1-1实际问题： 编写五子棋的程序中，有存盘退出和续上盘的操作功能。 因为创建的该二维数组中有许多数据都是默认值0，这就造成许多垃圾数据，那么我们转换成稀疏数组的话，就会解决垃圾数据的存在 2-1-2应用实例： 使用稀疏数组，来保留类似前边的二维数组（棋盘地图等） 把稀疏数组存盘，并且可可以恢复原来的二维数组 思路： 遍历原始的二维数组，得到有效的数字个...
Java数据结构与算法----稀疏数组和队列
qq_35710906的博客
03-13 660
文章目录稀疏数组和队列1.稀疏sparsearray数组1.1实际需求1.2 基本介绍1.3 应用实例1.4 代码演示 稀疏数组和队列 1.稀疏sparsearray数组 1.1实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题: 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据，所以推得了稀疏数组的概念。（去除这些没有意义的数据）。 1.2 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法： （1）记录数组
JAVA数组实现环形队列
yuanleidashen的博客
05-20 205
环形队列实现思路： 1.头指针front和尾指针rear都指向0。 2.环形队列判断是否满的条件：(rear+1)%maxSize==front 在数组的最后一个位置之前，尾指针rear的下一个位置可以用rear+1表示，但是当rear指向数组最后一个位置时 rear的下一个位置是0，所以实际上环形队列中rear的下一个位置是(rear+1)%maxSize，所以判断环形队列为满的条件是(rear+1)%maxSize == front 3.头指针和尾指针的下一个位置为(front+1)%maxSize，(
数据结构与算法-稀疏数组和队列
qq_45142938的博客
07-26 300
稀疏数组，队列，环形队列的数组实现
数据结构与算法-队列 数组 链表 | 尚硅谷韩顺平
weixin_54232666的博客
08-22 623
Java开发数据结构与算法 数据机构 数组 链表 队列 这篇就够了
数据结构与算法-稀疏数组
SimpleZihao的博客
01-22 201
看尚硅谷韩顺平老师的图解数据结构所写笔记
数据结构与算法·二 —— 稀疏数组和队列
un357951的博客
04-12 234
稀疏数组 二维数组压缩为稀疏数组 稀疏数组恢复为二维数组 队列 数组模拟队列 数组模拟循环队列 代码
数据结构与算法 第四章：稀疏数组和队列 -- 稀疏数组、链式存储压缩介绍、队列
天行健 君子以自强不息，地势坤 君子以厚德载物。
12-28 463
稀疏数组、链式存储压缩介绍、队列
[数据结构与算法-01]稀疏数组和队列
学哥斌的博客
03-30 295
1、稀疏数组（SparseArray） 1.1 需求场景   存在一个黑白棋盘，需要对棋盘数据进行存储和读取。   粗暴的解决方案：把棋盘看成是一个二维数组。   存在的问题：该二维数组存在大量的默认值0，因此记录了很多没有意义的数据。   比较优雅的解决方案：使用稀疏数组对棋盘数组进行压缩。 1.2 基本介绍   当一个数组中大部分元素为默认值时，可以使用稀疏数组来保存该数组。   稀疏数组的...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
数据结构与算法的学习：_稀疏数组、单向队列、环形队列、单向链表、双
09-23
数据结构与算法的学习：_稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、_dataStructuresAndAlgorithm
数据结构与算法-C#版
03-09
这是C#版的数据结构与算法的代码实现，包括：顺序表，单链表，双链表；顺序栈，链栈；顺序队列，链队列；顺序串；用数组进行特殊矩阵的存储，稀疏矩阵的存储；顺序存储二叉树，链式存储二叉树，哈夫曼树；多重链表...
中南大学数据结构与算法-课后习题参考答案(全部章节).pdf
05-22
### 数据结构与算法知识点解析 #### 一、基础概念解析 **1.1 简述下列概念** - **数据**: 数据是指能够被计算机识别、存储和加工处理的信息载体。它可以是数字、文本、图像、音频或视频等各种形式的信息。 - **...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 307
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 831
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1402
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 910
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 273
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值