1. 稀疏数组sparsearray
1.1 运用场景
- 编写的五子棋程序中, 有存盘退出和续上盘的功能。
- 分析问题:
因为该二维数组的很多值是默认值 0, 因此记录了很多没有意义的数据,这个时候我们就可以运用稀疏数组。
1.2 解决方案
- 当一个数组中大部分元素为0 , 或者为同一个值的数组时, 可以使用稀疏数组来保存该数组。
- 稀疏数组的处理方法:
- 稀疏数组一般是个N行3列的二维数组,第一行记录了数组包含几行几列,有多少个不同的值。
- 稀疏数组从第二行开始,记录数组不同的值在第几行、第几列及其具体的值,从而缩小程序的规模。
1.3 应用实例
- 使用稀疏数组, 来保留类似前面的二维数组(棋盘、 地图等等)
- 把稀疏数组存盘, 并且可以从新恢复原来的二维数组数
- 整体思路分析:
1.4 代码实现
package com.gtjt.xxjss.parsearry;
public class SparseArray {
/**
* 二维数组转换成稀疏数组
*
* @param dyadicArry
* @return
*/
public static int[][] dyadicArrayConvertIntoSparseArray(int[][] dyadicArry) {
//1.遍历原始的二维数组,得到有效数据的个数sum
int sum = 0;
for (int i = 0;i < dyadicArry.length;i++) {
for (int j = 0;j < dyadicArry[i].length;j++) {
if (dyadicArry[i][j] != 0) {
sum++;
}
}
}
//2.根据sum就可以创建稀疏数组sparseArray int[sum+1][3]
int[][] sparseArray = new int[sum+1][3];
sparseArray[0][0] = dyadicArry.length;
sparseArray[0][1] = sparseArray[0][0];
sparseArray[0][2] = sum;
//3.将二维数组的有效数据存入稀疏数组
int k = 1;
for (int i = 0;i < dyadicArry.length;i++) {
for (int j = 0;j < dyadicArry[i].length;j++) {
if (dyadicArry[i][j] != 0) {
sparseArray[k][0] = i;
sparseArray[k][1] = j;
sparseArray[k][2] = dyadicArry[i][j];
k++;
}
}
}
return sparseArray;
}
/**
* 稀疏数组转换成二维数组
*
* @param sparseArray
* @return
*/
public static int[][] sparseArrayConvertIntoDyadicArray(int[][] sparseArray) {
//1.先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组
int[][] dyadicArray = new int[sparseArray[0][0]][sparseArray[0][1]];
//2.在读取稀疏数组后几行的数据,并赋值给原始的二维数组即可
for (int i = 1;i <= sparseArray[0][2];i++) {
dyadicArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
}
return dyadicArray;
}
public static void main(String[] args) {
int[][] dyadicArry ={
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,1,0,0,0,0,0,0,0,0},
{0,0,0,2,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0}
};
System.out.println("原始的二维数组:");
for (int[] d : dyadicArry) {
for (int i = 0;i < d.length;i++) {
System.out.printf("%d\t", d[i]);
}
System.out.println();
}
int[][] sparseArray = dyadicArrayConvertIntoSparseArray(dyadicArry);
System.out.println("二维数组转换后的稀疏数组:");
for (int[] s : sparseArray) {
for (int i = 0;i < s.length;i++) {
System.out.printf("%d\t", s[i]);
}
System.out.println();
}
int [][] dyadicArry2 = sparseArrayConvertIntoDyadicArray(sparseArray);
System.out.println("稀疏数组转换后的二维数组:");
for (int[] d : dyadicArry2) {
for (int i = 0;i < d.length;i++) {
System.out.printf("%d\t", d[i]);
}
System.out.println();
}
}
}
1.5 程序运行结果
原始的二维数组:
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
二维数组转换后的稀疏数组:
11 11 2
1 2 1
2 3 2
稀疏数组转换后的二维数组:
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
1.4 课后练习
- 在前面的基础上, 将稀疏数组保存到磁盘上, 比如 map.data
- 恢复原来的数组时, 读取 map.data 进行恢复
2. 队列
2.1 队列的一个使用场景
银行排队的案例:
2.2 队列介绍
- 队列是一个有序列表, 可以用数组或是链表来实现。
- 遵循先入先出的原则。 即: 先存入队列的数据, 要先取出。 后存入的要后取出
- 示意图: (使用数组模拟队列示意图)
2.3 数组模拟队列思路
- 队列本身是有序列表, 若使用数组的结构来存储队列的数据, 则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。
- 因为队列的输出、 输入是分别从前后端来处理, 因此需要两个变量 front 及 rear 分别记录队列前后端的下标,
- front 会随着数据输出而改变, 而 rear 则是随着数据输入而改变, 如图所示:
- 当我们将数据存入队列时称为” addQueue” , addQueue 的处理需要有两个步骤: 思路分析
- 将尾指针往后移: rear+1 , 当 front == rear 【空】
- 若尾指针 rear 小于队列的最大下标 maxSize-1, 则将数据存入 rear 所指的数组元素中, 否则无法存入数据。rear == maxSize - 1[队列满]
2.4 代码实现
package com.gtjt.xxjss.queue;
import java.util.Scanner;
public class ArrayQueueDemo {
public static void main(String[] args) {
ArrayQueue queue = new ArrayQueue(3);
char key = ' ';
Scanner scanner = new Scanner(System.in);
boolean loop = true;
while (loop) {
System.out.println("s(show):显示队列");
System.out.println("e(exit):退出程序");
System.out.println("a(add):添加数据到队列");
System.out.println("g(get):从队列中取出数据");
System.out.println("h(head):查看队列头部数据");
key = scanner.next().charAt(0);
switch (key) {
case 's' :
queue.showQueue();
break;
case 'a' :
System.out.println("请输入一个整数:");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g' :
try {
int res = queue.getQueue();
System.out.printf("取出的数据是:%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h' :
try {
int res = queue.headQueue();
System.out.printf("队列头部的数据是:%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e' :
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~");
}
}
class ArrayQueue {
private int maxSize;//队列最大长度
private int front;//指向队列头部前一个位置
private int rear;//指向队列尾部,包含尾部
private int[] array;
//构造一个长度为size的队列
public ArrayQueue(int size) {
maxSize = size;
front = -1;//队列头部,指向的是队列头的前一个位置
rear = -1;//队列尾部,指向队列尾的数据(队列的最后一个数据)
array = new int[size];
}
//判断队列是否空
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++;
array[rear] = n;
}
//从队列中取数
public int getQueue() {
if (isEmpty()) {
throw new RuntimeException("队列空,不能取数!");
}
front++;
return array[front];
}
//显示队列
public void showQueue() {
if (isEmpty()) {
System.out.println("队列为空,没有数据!");
return;
}
for (int i = (front + 1);i < rear + 1;i++) {
System.out.printf("array[%d]:%d\n",i, array[i]);
}
}
//取出队列头数据
public int headQueue() {
if (isEmpty()) {
throw new RuntimeException("队列空,不能取数!");
}
return array[front + 1];
}
}
2.5 程序运行结果
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
1
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
4
队列满,不能存数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
h
队列头部的数据是:1
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:1
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[1]:2
array[2]:3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
队列空,不能取数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
队列为空,没有数据!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
4
队列满,不能存数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
2.6 问题分析并优化
- 目前数组使用一次就不能用, 没有达到复用的效果
- 将这个数组使用算法, 改进成一个环形的队列 取模: %
3. 数组模拟环形队列
3.1 对前面的数组模拟队列进行优化, 充分利用数组,可将数组看是一个环形的。 (通过取模的方式来实现)
- 分析说明:
- 尾索引的下一个为头索引时表示队列满, 即将队列容量空出一个作为约定,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 满]
- rear == front [空]
- 分析示意图:
3.2 代码实现
package com.gtjt.xxjss.queue;
import java.util.Scanner;
public class CircleArrayQueueDemo {
public static void main(String[] args) {
CircleArrayQueue queue = new CircleArrayQueue(4);
char key = ' ';
Scanner scanner = new Scanner(System.in);
boolean loop = true;
while (loop) {
System.out.println("s(show):显示队列");
System.out.println("e(exit):退出程序");
System.out.println("a(add):添加数据到队列");
System.out.println("g(get):从队列中取出数据");
System.out.println("h(head):查看队列头部数据");
key = scanner.next().charAt(0);
switch (key) {
case 's' :
queue.showQueue();
break;
case 'a' :
System.out.println("请输入一个整数:");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g' :
try {
int res = queue.getQueue();
System.out.printf("取出的数据是:%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h' :
try {
int res = queue.headQueue();
System.out.printf("队列头部的数据是:%d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e' :
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~");
}
}
class CircleArrayQueue {
private int maxSize;//队列最大长度
private int front;//指向队列头部,队列第一个元素的位置
private int rear;//指向队列尾部,队列最后一个元素的下一个位置(因为预留出一个空间,区分队列满和队列空的情况)
private int[] array;
//构造器
public CircleArrayQueue(int size) {
maxSize = size;
front = 0;
rear = 0;
array = new int[size];
}
//判断队列是否空
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;
}
array[rear] = n;//直接将数据写入
rear = (rear + 1) % maxSize;//将rear后移, 这里要考虑取模
}
//从队列中取数
public int getQueue() {
if (isEmpty()) {
throw new RuntimeException("队列空,不能取数!");
}
// 因为front是指向队列的第一个元素
// 1. 先把 front 对应的值保留到一个临时变量
// 2. 将 front 后移, 要考虑取模
// 3. 将临时保存的变量返回
int val = array[front];
front = (front + 1) % maxSize;
return val;
}
//显示队列的所有数据
public void showQueue() {
if (isEmpty()) {
System.out.println("队列为空,没有数据!");
return;
}
// 思路:从front开始遍历,遍历多少个元素
// 关键点:环形队列,front的值会在0到maxSize-1之间不断循环
for (int i = front;i < front + size();i++) {
System.out.printf("array[%d]:%d\n",i % maxSize, array[i % maxSize]);
}
}
//计算队列的有效值个数
public int size() {
return ((rear - front + maxSize) % maxSize);
}
//取出队列头数据
public int headQueue() {
if (isEmpty()) {
throw new RuntimeException("队列空,不能取数!");
}
return array[front];
}
}
3.3 程序运行结果
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
1
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
4
队列满,不能存数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[0]:1
array[1]:2
array[2]:3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:1
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
h
队列头部的数据是:2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:2
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[2]:3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:3
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
队列空,不能取数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
4
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
5
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[3]:4
array[0]:5
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
6
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
7
队列满,不能存数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[3]:4
array[0]:5
array[1]:6
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
g
取出的数据是:4
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
h
队列头部的数据是:5
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
7
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[0]:5
array[1]:6
array[2]:7
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
a
请输入一个整数:
8
队列满,不能存数!
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据
s
array[0]:5
array[1]:6
array[2]:7
s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取出数据
h(head):查看队列头部数据