尚硅谷Java数据结构与算法第三章——稀疏数组和队列-计算机考试-空麓网

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

第 3 章稀疏数组和队列
- 3.1 稀疏 sparsearray 数组
- - 3.1.1 实际需求
  - 3.1.2 基本介绍
  - 3.1.3 应用实例
- 3.2 队列
- - 3.2.1 使用场景
  - 3.2.2 队列介绍
  - 3.2.3 数组模拟队列
  - 3.2.4 数组模拟环形队列

第 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]=%dn", 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]=%dn", i % maxSize, arr[i % maxSize]);
		}
	}

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

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

}

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

Java相关栏目本月热门文章