【韩顺平-数据结构】稀疏矩阵和队列（学习笔记）

已于 2023-08-04 13:56:20 修改
阅读量56 收藏
点赞数
分类专栏： 数据结构（学习笔记） 文章标签： 数据结构 矩阵 学习
于 2023-08-04 13:49:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh1024/article/details/132102758
版权

一、稀疏数组sparsearray

1、应用场景

需求：五子棋”存盘退出“ --> 二维数组保存

问题：这个二维数组大部分都是默认值0，记录了很多没有意义的数据 --> 稀疏数组

2、稀疏数组

稀疏数组：数组大部分为同一个值

处理方法：记录数组几行几列，有多少个的值。把不同值的行和列记录在小规模数组中。

行号row列号col值value
[0]222
[1]011
[2]101

[0]：共几行几列，存在几个值

[1] - [n]：记录x行x列的值是多少

3、思路分析

1）二维转稀疏

  1. 遍历原始二维数组，得到有效数据个数 -> sum
  2. 创建稀疏数组sparseArr int[sum][3]
  3. 将有效数据存到sparseArr中

2）稀疏转二维

  1. 读取sparseArr的第一行的数据创建原始二维数组
  2. 读取sparseArr后面的数值，赋值给二维数组

4、代码实现

1）基础代码

package work.rexhao.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;
		// 输出
		System.out.println("原始二维数组");
		for(int[] row : chessArr1) {
			for(int i : row) {
				System.out.printf("%d ",i);
			}
			System.out.println();
		}
		
		// 将二维数组转换成稀疏数组
		// 1.遍历二维数组，得到非0个数、行和列
		int r = 0, l = 0, v = 0;
		for(int[] row : chessArr1) {
			r++;
			for(int i : row) {
				l++;
				if(i != 0) {
					v++;
				}
			}
		}
		l /= r;
		
		// 2.创建稀疏数组
		int sparseArr[][] = new int[v+1][3];
		
		// 3.给稀疏数组赋值
		sparseArr[0][0] = r;
		sparseArr[0][1] = l;
		sparseArr[0][2] = v;
		int ii = 0;
		for(int i = 0; i < r; i++) {
			for(int j = 0; j < l; j++) {
				if(chessArr1[i][j] != 0) {
					sparseArr[++ii][0] = i;
					sparseArr[ii][1] = j;
					sparseArr[ii][2] = chessArr1[i][j];
				}
			}
		}
		
		// 稀疏数组的输出
		System.out.println("得到的稀疏数组是：");
		for(int[] row : sparseArr) {
			for(int i : row) {
				System.out.print(i + " ");
			}
			System.out.println();
		}
		
		// 将稀疏数组恢复二维数组
		// 1.读取第一行，创建二维数组
		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
		
		// 2.读取并赋值
		for(int i = 1; i <= sparseArr[0][2]; i++) {
			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
		}
		
		// 输出
		System.out.println("转换的二维数组是：");
		for(int[] row : chessArr2) {
			for(int i : row) {
				System.out.printf("%d ",i);
			}
			System.out.println();
		}
	}

}

2）IO代码

package work.rexhao.sparsearray;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class sparsearray_out {
	public static void main(String[] args) throws FileNotFoundException, IOException {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./chess.data"));
		// 创建一个原始的二维数组11*11
		// 0：没有旗子，1：黑子，2：蓝子
		int chessArr1[][] = new int[11][11];
		chessArr1[1][2] = 1;
		chessArr1[1][3] = 2;
		// 将二维数组转换成稀疏数组
		// 1.遍历二维数组，得到非0个数、行和列
		int r = 0, l = 0, v = 0;
		for (int[] row : chessArr1) {
			r++;
			for (int i : row) {
				l++;
				if (i != 0) {
					v++;
				}
			}
		}
		l /= r;

		// 2.创建稀疏数组
		int sparseArr[][] = new int[v + 1][3];

		// 3.给稀疏数组赋值
		sparseArr[0][0] = r;
		sparseArr[0][1] = l;
		sparseArr[0][2] = v;
		int ii = 0;
		for (int i = 0; i < r; i++) {
			for (int j = 0; j < l; j++) {
				if (chessArr1[i][j] != 0) {
					sparseArr[++ii][0] = i;
					sparseArr[ii][1] = j;
					sparseArr[ii][2] = chessArr1[i][j];
				}
			}
		}
		
		
		// 4.序列化
		oos.writeObject(sparseArr);
		oos.close();
		System.out.println("存档成功！");
	}
}

package work.rexhao.sparsearray;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class sparsearray_in {

	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./chess.data"));
		int sparseArr[][] = (int[][])ois.readObject();
		System.out.println("读档成功!");
		// 将稀疏数组恢复二维数组
		// 1.读取第一行，创建二维数组
		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
		
		// 2.读取并赋值
		for (int i = 1; i <= sparseArr[0][2]; i++) {
			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
		}

		// 输出
 		for (int[] row : chessArr2) {
			for (int i : row) {
				System.out.printf("%d ", i);
			}
			System.out.println();
		}

	}

}

二、队列

1、队列概述

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

遵循先入先出原则

2、数组模拟队列

1）数组结构介绍

数组的结构存储队列元素，maxSize是队列最大容量

两个变量front和rear记录队列前后端

2）思路分析

  1. 尾指针后移：rear+1
  2. rear < maxSize - 1：可以存

当front == rear，队列空

当rear == maxSize - 1，队列满

3）代码实现

package work.rexhao.queue;

import java.util.Scanner;

public class arrayQueueDemo {

	public static void main(String[] args) {
		ArrayQueue aq = new ArrayQueue(3);
		boolean loop = true;
		while (loop) {
			Scanner sc = new Scanner(System.in);
			System.out.println("1. 添加数据");
			System.out.println("2. 弹出数据");
			System.out.println("3. 显示首数据");
			System.out.println("4. 遍历");
			System.out.println("0. 退出");
			int key = sc.nextInt();
			if (key == 1) {
				System.out.println("请输入需要添加的数据");
				int value = sc.nextInt();
				aq.addQueue(value);
			} else if (key == 2) {
				try {
					int value = aq.getQueue();
					System.out.printf("弹出元素：%d\n",value);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}

			} else if (key == 3) {
				try {
					int value = aq.headQueue();
					System.out.printf("首元素：%d\n", value);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
			} else if (key == 4) {
				aq.showQueue();
			} else if (key == 0) {
				loop = false;
			} else {
				System.out.println("请检查输入");
			}
		}
	}

}

/**
 * 使用数组模拟队列----编写一个ArrayQueue类
 */
class ArrayQueue {
	private int maxSize; // 数组最大容量
	private int front; // 队列头
	private int rear; // 队列尾
	private int[] arr; // 队列的数据

	/**
	 * 创建队列的构造器
	 */
	public ArrayQueue(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[arrMaxSize];
		front = -1;// 指向队列头的前一个位置
		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;
		}
		arr[++rear] = n;
	}

	/**
	 * 出队列
	 */
	public int getQueue() {
		if (isEmpty()) {
			// 抛出异常 -- 不需要写return
			throw new RuntimeException("队列空");
		}
		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];
	}
}

4）问题与优化

  1. 对于普通队列，数组使用一次就不能用，没有达到复用的效果
  2. 将这个数组使用算法，改进成一个环形的队列 （取模：%）

3、数组模拟环形队列

1）思路分析

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

2）代码实现

package work.rexhao.queue;

import java.util.Scanner;

public class circleQueueDemo {

	public static void main(String[] args) {
		CircleQueue cq = new CircleQueue(3);
		boolean loop = true;
		while (loop) {
			Scanner sc = new Scanner(System.in);
			System.out.println("1. 添加数据");
			System.out.println("2. 弹出数据");
			System.out.println("3. 显示首数据");
			System.out.println("4. 遍历");
			System.out.println("0. 退出");
			int key = sc.nextInt();
			if (key == 1) {
				System.out.println("请输入需要添加的数据");
				int value = sc.nextInt();
				cq.addQueue(value);
			} else if (key == 2) {
				try {
					int value = cq.getQueue();
					System.out.printf("弹出元素：%d\n", value);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}

			} else if (key == 3) {
				try {
					int value = cq.headQueue();
					System.out.printf("首元素：%d\n", value);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
			} else if (key == 4) {
				cq.showQueue();
			} else if (key == 0) {
				loop = false;
			} else {
				System.out.println("请检查输入");
			}
		}

	}

}

/**
 * 使用数组模拟环形队列----编写一个CircleQueue类
 */
class CircleQueue {
	private int maxSize; // 数组最大容量
	private int front; // 队列头
	private int rear; // 队列尾
	private int[] arr; // 队列的数据

	/**
	 * 创建队列的构造器
	 */
	public CircleQueue(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[arrMaxSize];
		front = 0;// 指向队列头
		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;
		}
		arr[rear] = n;
		rear = (rear + 1) % maxSize;
	}

	/**
	 * 出队列
	 */
	public int getQueue() {
		if (isEmpty()) {
			// 抛出异常 -- 不需要写return
			throw new RuntimeException("队列空");
		}
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}

	/**
	 * 遍历？？？
	 */
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列空！");
			return;
		}
		for (int i = front; i < front + size(); i++) {
			System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i % maxSize]);
		}
	}

	/**
	 * 显示头数据（不取出）
	 */
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列空");
		}
		return arr[front];
	}

	/**
	 * 有效数据
	 */
	public int size() {
		return (rear - front + maxSize) % maxSize;
	}
}
wmh1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
数据结构和算法----稀疏数组.rar
09-17
总结来说，本学习笔记深入浅出地介绍了稀疏数组这一数据结构，通过韩顺平老师的讲解，让我们了解到如何有效地处理大量稀疏数据，以及如何设计和实现相关的算法。掌握稀疏数组不仅能够优化内存使用，还能提升算法性能...
【韩顺平-数据结构】排序（学习笔记）
wmh的博客
12-28 279
冒泡排序（Bubble Sorting）：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的希尔排序是希尔 (Donald Shell）于 1959 年提出的一种排序算法。
【韩顺平-数据结构】图（学习笔记）
wmh的博客
08-04 62
图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。（结点也可以称为顶点）
数据结构Java（韩顺平）稀疏矩阵学习
m0_55895641的博客
03-03 488
导师那边项目催着做，学习的时间明显减少，所以决定java康师傅和数据结构一块进行，今天主要学习了稀疏矩阵和二维数组的转换，内容还是比较简单的，简单整理了一下自己觉得需要记录的笔记如下：韩老师水平确实很高，讲解的也非常透彻。 Day01： 线性结构：数组、链表、队列、栈 非线性结构：二维数组、多维数组、广义表、树结构、图结构 稀疏数组：只记录数组的维度和非零元素的位置和值（相当于记录非零元素的坐标）第0行记录的是维度。 二维数组转稀疏数组的思路： 稀疏数组转二维数组： 增强for
韩顺平老师数据结构与算法学习笔记
指尖上的革新
11-19 2035
目录 数据结构与算法 介绍课程的重要性，介绍了数据结构与算法的关系，分类等 稀疏数组 介绍什么是稀疏数组与相关应用 队列 介绍队列的实现，环形队列的实现 链表 介绍什么是链表；单向链表及双向链表实现及应用等 单向环形链表约瑟夫问题 介绍约瑟夫问题的处理方案 栈 介绍什么是栈，栈的应用，前中后缀表达式，逆波兰计算器等 递归 递归的介绍，递归解决实际问题：迷宫问题及八皇后问题等 排序 介绍了常用的几大排序：冒泡，选择，插入，希尔，快排，归并，基数排序等知识 查找算法 介绍常用的查找算法：二分查找，插值查找，斐波
数据结构与算法笔记（尚硅谷韩顺平）
fjasflmav的博客
02-18 808
本文为个人学习数据结构与算法的笔记。记录内容可能不尽详细
数据结构（韩顺平）队列学习_数组与队列
m0_55895641的博客
03-05 70
队列：先入先出 用数组模拟队列： 代码实现： package com.atguigu.queue; import jdk.internal.org.objectweb.asm.tree.TryCatchBlockNode; import java.util.Scanner; /** * @author * @create 2022-03-04-11:20 */ public class ArrayQueueDemo { public static void main(.
数据结构-稀疏数组和队列
skycanf的博客
04-08 163
一、稀疏 sparsearray 数组 1、先看一个实际的需求 编写的五子棋程序中，有存盘退出和续上盘的功能。 分析问题: 因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据.->稀疏数组。 2、基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同值的...
韩顺平数据结构笔记环形数组实现队列
weixin_52688663的博客
11-13 414
需求：使用环形数组，完成在有限空间内不断取数据不断加数据(模拟银行排队叫号办业务) 主要思路： 1、front是头指针，指向数组的第一个元素，arr[front] 就是队列的第一个元素 ，且他的初始值为0 2、rear是队列的尾指针，指向数组的最后一个位置的前一个元素，留出最后一个位置作为约束，最后一个位置是取不到的 主要算法： 1、判断是否为空：rear == front 2、判断是否为满：（rear+1）% maxSize == front 3、**计算有效数字个数运用size方法： （.
数据结构(韩顺平)队列学习之环形队列
m0_55895641的博客
03-07 169
将上一段代码转换为环形队列，其核心思想用通俗的话来说，就是转了一圈又回到原点，个人认为其精华的点在于取数据操作和判断是否满，取完数据以后，front向后移动，形成新的起点。确实很有意思，学一把！ package com.atguigu.queue; import java.util.Scanner; /** * @author * @create 2022-03-07-14:24 */ public class CircleArrayQueue { public static voi
Linux-韩顺平学习笔记 - PDF-PPT
07-28
Linux课程学习笔记 -韩顺平 包含c/c++/python/java 专项 面试题 PDF PPT 笔记 面试题 （百度网盘链接 永久有效） 自学,做笔记,复习可用
尚硅谷-韩顺平-Go语言核心编程完整版笔记和代码
08-28
《尚硅谷-韩顺平-Go语言核心编程完整版笔记和代码》是针对Go语言学习者的一份宝贵资源，由知名讲师韩顺平在尚硅谷教育机构讲授的课程整理而成。这份资料集包含了详细的笔记和配套的源代码，旨在帮助初学者深入理解Go...
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 389
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 330
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 763
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 509
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wmh1024

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

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

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

打赏作者

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

抵扣说明：

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

余额充值