尚硅谷Java数据结构与算法第三章——稀疏数组和队列

已于 2022-04-23 15:17:08 修改
阅读量812 收藏 1
点赞数
分类专栏： # 数据结构与算法 文章标签： java 数据结构
于 2022-04-21 17:22:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yw_1121/article/details/124198925
版权

尚硅谷Java数据结构与算法第三章——稀疏数组和队列

第 3 章 稀疏数组和队列

3.1 稀疏 sparsearray 数组

3.1.1 实际需求

编写的五子棋程序中，有存盘退出和续上盘的功能。
五子棋程序
分析问题:
因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据 -> 稀疏数组

3.1.2 基本介绍

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

  • 稀疏数组的处理方法是:
    ① 记录数组一共有几行几列，有多少个不同的值
    ② 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
    在这里插入图片描述
    稀疏数组的第一行[0]保存原始数组共有几行几列以及共有几个位置上有值，下边的各行分别表示存有值的数据在几行几列以及具体的值。
    对于上述例子，通过转换，我们将一个6*7的数组转换成了3*9的数组。

3.1.3 应用实例

  • 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)

  • 把稀疏数组存盘，并且可以从新恢复原来的二维数组数

  • 整体思路分析
    稀疏数组思路分析

    1. 二维数组转稀疏数组的思路
      ① 遍历原始的二维数组，得到有效数据的个数 sum
      ② 根据sum 就可以创建 稀疏数组 sparseArr int[sum + 1] [3]
      sum+1的原因是需要第一行来存数组的相关信息
      ③ 将二维数组的有效数据数据存入到稀疏数组
    2. 稀疏数组转原始的二维数组的思路
      ① 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
      ② 在读取稀疏数组后几行的数据，并赋给 原始的二维数组即可

  • 代码实现

    package com.atguigu.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] = 2;
		// 输出原始的二维数组
		System.out.println("原始的二维数组为：");
		for (int[] row : chessArr1) {
			for (int data : row) {
				System.out.print(data + "\t");
			}
			System.out.println();
		}
		
		
		// 将二维数组 转 稀疏数组的思路
		// 1. 遍历原始二维数组，得到非0的数据的个数
		int sum = 0;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr1[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 = 1;
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (chessArr1[i][j] != 0) {
					sparseArr[count][0] = i;
					sparseArr[count][1] = j;
					sparseArr[count][2] = chessArr1[i][j];
					count++;
				}
			}
		}
		
		// 输出转换完成的稀疏数组
		System.out.println();
		System.out.println("转换完成的稀疏数组为：");
		for(int i = 0; i < sparseArr.length; i++) {
			System.out.println(sparseArr[i][0] + "\t" + sparseArr[i][1] + "\t" + sparseArr[i][2]);
		}
		
		
		// 将稀疏数组 转回 二维数组的思路
		// 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
		// 2.再读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
		for(int i = 1;i < sparseArr.length;i++) {
			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
		}
		
		// 输出恢复后的二维数组
		System.out.println();
		System.out.println("恢复后的二维数组为：");
		for(int[] row : chessArr2) {
			for(int data : row) {
				System.out.print(data + "\t");
			}
			System.out.println();
		}
		
	}
}

3.2 队列

3.2.1 使用场景

银行排队的案例：按照顺序叫号
银行排队

3.2.2 队列介绍

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

3.2.3 数组模拟队列

  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。
  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示:
    数组模拟队列
  • 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
    1. 初始化：
      ① 创建两个指针front及 rear分别记录队列前后端的下标，两个指针都初始化为 -1，front指向队列第一个元素的前一个位置，rear指向最后一个元素本身位置
      ② 声明属性maxSize 记录该队列的最大容量
      ③ 声明属性arr数组用于存放数据，模拟队列
    2. 添加时：
      ① 判断数组是否已满（rear == maxSize-1）
      ② 未满时，尾指针rear后移，并将数据存入rear所指的元素位置
    3. 取出时：
      ① 判断数组是否为空（front == rear）
      ② 不为空时，头指针front后移，并将现在front所指位置的元素返回，此时front指向的仍为队列首元素的前一个位置
  • 代码实现
    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 scan = new Scanner(System.in);
		boolean isFlag = true;
		while(isFlag) {
			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 = scan.next().charAt(0);
			switch (key) {
			case 's': 
				queue.showQueue();
				break;
			case 'a':
				System.out.println("输入一个数：");
				int value = scan.nextInt();
				queue.addQueue(value);
				break;
			case 'g':
				try {
					int data = queue.getQueue();
					System.out.println("取出的数据是：" + data);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'h': //查看队列头的数据
				try {
					int head = queue.headQueue();
					System.out.println("队列头的数据是:" + head);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				scan.close();
				isFlag = 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 arrMixSize) {
		maxSize = arrMixSize;
		arr = new int[maxSize];
		front = -1;
		rear = -1;
	}

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

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

	// 添加数据到队列
	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];
	}
}
  • 问题分析并优化
    ① 目前数组使用一次就不能用， 没有达到复用的效果
    （取出数据时只是将指针后移，并没有释放数组队列中存放已取出数据的位置的空间，尾指针也只是从数组队列的头到尾后停止，一次性使用，会导致假溢出问题）
    ② 将这个数组使用算法，改进成一个环形的队列 取模：%

3.2.4 数组模拟环形队列

  • 解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。
    对前面的数组模拟队列的优化，充分利用数组。与普通队列不同，环形队列可以使得资源进行重复利用。

  • 思路分析：
    此时，首先，对于环形队列，指针需要在环形内部运动，因此初始值不能再设为-1，应当改为0。front也不应该再指向为第一个元素的上一个元素，而是元素本身位置。为保证当只有一个元素时，首尾指针的指向不同，rear不应当再指向最后一个元素，而是指向最后一个元素的下一个位置。当环形队列为空或者为满时，示意图如下：
    在这里插入图片描述
    此时存在问题：两种情况下都为首尾指针重合，无法进行区分
    因此我们在实现时需要预留一个约定空间来进行空队列和满队列的区分，尾指针指向此空间，如下图：
    情况1：
    在这里插入图片描述
    情况2：
    在这里插入图片描述
    此时，队列的数据容量比初始化的空间损失1，但可以完成空队列和满队列的区分。
    空队列时：front == rear —— 每次元素出队列时首指针会后移，两指针重合时为空
    满队列时：(rear + 1) % maxSize = front —— 尾指针的下一个为首指针时为满
    队列实际容量：(rear - front + maxSize) % maxSize
    队列实际容量分析

    1. 初始化：
      ① 创建两个指针front及 rear分别记录队列前后端的下标，两个指针都初始化为 0，front指向队列第一个元素的位置，rear指向最后一个元素后一个位置
      ② 声明属性maxSize 记录该队列的最大容量
      ③ 声明属性arr数组用于存放数据，模拟队列
    2. 添加时：
      ① 判断数组是否已满（rear == maxSize-1）
      ② 未满时，尾指针rear后移，并将数据存入rear所指的元素位置
    3. 取出时：
      ① 判断数组是否为空（front == rear）
      ② 不为空时，头指针front后移，并将现在front

  • 代码实现

    package com.atguigu.queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
	public static void main(String[] args) {
		// 测试
		CircleArray queue = new CircleArray(4);//此时，环形数列最大存储容量为3
		char key;// 接收用户输入
		Scanner scan = new Scanner(System.in);
		boolean isFlag = true;
		while (isFlag) {
			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 = scan.next().charAt(0);
			switch (key) {
			case 's':
				queue.showQueue();
				break;
			case 'a':
				System.out.println("输入一个数：");
				int value = scan.nextInt();
				queue.addQueue(value);
				break;
			case 'g':
				try {
					int data = queue.getQueue();
					System.out.println("取出的数据是：" + data);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'h': // 查看队列头的数据
				try {
					int head = queue.headQueue();
					System.out.println("队列头的数据是:" + head);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				scan.close();
				isFlag = false;
				break;
			default:
				break;
			}
		}

		System.out.println("程序退出~");

	}
}

class CircleArray {
	private int maxSize; // 数组的最大容量
	private int front; // 队列头,含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
	private int rear; // 队列尾,含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
	private int[] arr; // 该数组用于存放数据，模拟队列

	// 创建队列的构造器
	public CircleArray(int arrMixSize) {
		maxSize = arrMixSize;
		arr = new int[maxSize];
	}

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

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

	// 添加数据到队列
	public void addQueue(int n) {
		// 判断数据是否已满
		if (isFull()) {
			System.out.println("队列已满，不能再加入数据！");
			return;
		}
		// rear指向队尾的下一个位置，因此直接加入元素即可
		arr[rear] = n;
		// rear指针后移，这里必须考虑取模
		rear = (rear + 1) % maxSize;
	}

	// 获取队列的数据, 出队列
	public int getQueue() {
		// 判断队列是否为空
		if (isEmpty()) {
			throw new RuntimeException("队列为空，不能获取数据！");
		}
		// front指向的即为需要返回的元素(队列的第一个元素)
		// 但如果直接返回，会导致无法再对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];
	}

}

    输出结果

荔枝小丸子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
【尚硅谷Java数据结构与算法】稀疏数组
Ep流苏的博客
03-24 333
1. 实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题: 因为该二维数组的很多值是默认值 0, 因此记录了 很多没有意义的数据。 这个时候就可以使用稀疏数组来压缩二维数组。 2. 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组 一共有几行几列，有多少个有效值 把具有不同值的元素的行、列及值记录在一个小规模的数组中，从而缩小程序的规模 示例：二维数组和对应的稀疏数组 3. 应用实例 分析 使用稀疏数组，
稀疏数组的实现(尚硅谷Java数据结构与算法)
ALi的博客
09-09 92
整个代码放在main函数中就可以运行 从数组---->稀疏数组 int arrays[][] = new int[11][11]; arrays[1][2] = 1; arrays[2][3] = 2; //打印初始化的数组 for (int i = 0;i<arrays.length;i++){ for (int j = 0;j<arrays[i].length;j++){
尚硅谷Java数据结构与java算法（Java数据结构与算法）.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
尚硅谷 java数据结构和算法.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
【尚硅谷】数据结构与算法（Java数据结构与算法）.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
Java内存模型
最新发布
weixin_44267758的博客
07-19 339
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 876
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 724
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 931
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 175
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 514
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 599
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 534
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 524
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 503
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 374
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 219
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值