1 稀疏数组
1.1 实际需求
二维数组的很多值是默认值 0 ，记录了很多没有意义的数据，可以将其转为稀疏数组进行存储。
1.2 稀疏数组应用实例
- 原始数组转换成稀疏数组（代码）
//测试代码
class Demo{
public static void main(String[] args){
//创建一个11*11的二维数组
// 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
int[][] array = new int[11][11];
array[1][2] = 1;//黑子位置
array[2][3] = 2;//蓝子位置
System.out.println("打印原始数组：");
PrintArray.printArray(array);
//调用转换成稀疏数组的方法
int[][] arr = SparseArray.sparseArray(array);
//打印稀疏数组
System.out.println("打印稀疏数组：");
PrintArray.printArray(arr);
//调用还原成原始数组的方法
int[][] yArr = FanSparseArray.fanSparseArray(arr);
//打印稀疏数组
System.out.println("打印原始数组：");
PrintArray.printArray(yArr);
}
}
class SparseArray{
//将原始数组转换成稀疏数组
public static int[][] sparseArray(int[][] arr){
//1.先遍历原始数组，得到有效数据个数
int sum = 0;
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
if(arr[i][j] != 0){
sum++;
}
}
}
//2.根据有效数据个数创建稀疏数组
int[][] sparseArr = new int[sum+1][3];
//3.将原始数组中的有效数据存入稀疏数组
//稀疏数组第一行存放原始数组行数，列数，有效数据个数
sparseArr[0][0] = arr.length;
sparseArr[0][1] = arr[0].length;
sparseArr[0][2] = sum;
//稀疏数组从第二行开始存放：有效数据的行数，列数，数值
int count = 0;//定义有效数据的个数
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
if(arr[i][j] != 0){
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = arr[i][j];
}
}
}
return sparseArr;
}
}
class FanSparseArray{
//将稀疏数组还原成原始数组
public static int[][] fanSparseArray(int[][] arr){
//1.先读取稀疏数组的第一行，创建原始数组
int[][] yArray = new int[arr[0][0]][arr[0][1]];
//2.读取稀疏数组后n行数据，赋值给原始二维数组
for(int i =1; i <= arr[0][2]; i++){
int row = arr[i][0];
int col = arr[i][1];
yArray[row][col] = arr[i][2];
}
return yArray;
}
}
//打印二维数组(循环嵌套)
class PrintArray{
public static void printArray(int[][] arr){
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
- 结果截图
2 队列（Queue）
2.1 概述
- 队列是一种特殊的线性表，可以用数组或者链表实现。尾部添加，头部删除，FIFO。
2.2 数组模拟队列
- 队列容量：maxSize
- 队列判空：front == rear
- 队列判满：rear == （maxsize - 1）
- 队列元素个数：rear - front
- 元素入队列条件：队列没满
- 元素出队列条件：队列没空
代码实现
package com.tony.queue;
public class ArrayQueue {
private int maxSize;// 表示数组的最大容量
private int front; // 表示队列头
private int rear; // 表示队列尾
private int[] arr; // 该数组用于存放数据，模拟队列
// 队列的构造函数
public ArrayQueue(int maxSize) {
this.maxSize = maxSize;
arr = new int[maxSize];
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;
}
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 = front + 1; i <= rear; i++){
System.out.println("arr["+i+"]="+arr[i]);
}
}
// 显示队列的头数据， 注意不是取出数据
public int headQueue(){
//判空
if(isEmpty()){
System.out.println("队列为空，没有数据");
}
return arr[front + 1];
}
}
import java.util.Scanner;
class ArrayQueueDemo{
public static void main(String[] args){
//创建一个队列
ArrayQueue queue = new ArrayQueue(3);
String key = "";
//键盘输入
Scanner sc = new Scanner(System.in);
//循环标志
boolean loop = true;
while(loop){
System.out.println("show: 显示队列");
System.out.println("exit: 退出程序");
System.out.println("add: 添加数据到队列");
System.out.println("get: 从队列取出数据");
System.out.println("head: 查看队列头的数据");
key = sc.nextLine(); //接收一个字符串
switch(key){
case"show":
queue.showQueue();
break;
case"add":
System.out.println("请输入一个数:");
int value = sc.nextInt();
queue.addQueue(value);
break;
case"get":
try{
int res = queue.getQueue();
System.out.println("取出的数据是"+res);
}catch(Exception e){
System.out.println(e.getMessage());
}
break;
case "head":
try{
int res = queue.headQueue();
System.out.println("队列头的数据是"+res);
}catch(Exception e){
System.out.println(e.getMessage());
}
break;
case "exit":
sc.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~");
}
}
- 目前数组只能使用一次，没有达到复用的效果，造成了空间的浪费。
2.3 数组模拟环形队列
- front指向队列头的位置，即arr[front]是队列的第一个元素，front初始值为0
- rear指向队列尾的后一个位置。rear初始值为0
- 队列满的条件：(rear + 1)%maxSize == front
- 队列空的条件：rear == front
- 队列中有效数据个数：(rear + maxSize - front)%maxSize
- 队列容量：maxSize - 1
- 队列判满：
为何要在 rear 之后，front 之前空出一个元素的空间？因为如果不空出一个元素，队列判空条件为：front == rear ，队列判满的条件也是：front == rear ，有歧义！
队列容量：因为空出了一个元素，所以队列容量就变成了 (maxSize - 1)
当空出一个元素的空间，如何判满？当还剩一个元素时，队列就已经满了，所以判断条件为 (rear + 1) % maxSize == front - 队列元数个数：
计算公式：(rear + maxSize - front) % maxSize ，这样来思考：
当 rear 比 front 大时，即 (rear -front) > 0 ，这时还没有形成环形结构，(rear -front) 即是队列元素个数
当 rear 比 front 小时，即 (rear -front) < 0 ，这时已经形成了环形结构，(rear -front) 表示数组还差多少个元素存满（负数），(rear + maxSize - front) 即是队列元素个数
综上：(rear + maxSize - front) % maxSize - 队列入队：
首先，队列不满才能入队
由于 rear 指向队列尾部元素的后一个元素，所以直接设置即可： arr[rear] = value
接下来，rear 应该向后移动一个位置：rear = (rear + 1) % maxSize
取模是为了防止数组越界，让指针从新回到数组第一个元素 - 队列出队：
首先，队列不空才能出队
由于 front 直接指向队列头部元素，所以直接返回该元素即可：int value = arr[front ]
接下来，front 应该向后移动一个位置：front = (front + 1) % maxSize
取模是为了防止数组越界，让指针从新回到数组第一个元素
class CircleArray{
private int maxSize; // 表示数组的最大容量
// front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
// front 的初始值 = 0
private int front;
// rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
// rear 的初始值 = 0
private int rear; // 队列尾
private int[] arr; // 该数据用于存放数据, 模拟队列
//构造方法
public CircleArray(int maxSize) {
this.maxSize = maxSize;
arr = new int[maxSize];
}
// 判断队列是否满
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 = (rear + 1) % maxSize;
}
// 获取队列的数据, 出队列
public int getQueue() {
// 判断队列是否空
if (isEmpty()) {
// 通过抛出异常
throw new RuntimeException("队列空，不能取数据");
}
// 这里需要分析出 front是指向队列的第一个元素
// 1. 先把 front 对应的值保留到一个临时变量
// 2. 将 front 后移, 考虑取模
// 3. 将临时保存的变量返回
int temp = arr[front];
front = (front + 1) % maxSize;
return temp;
}
// 显示队列的所有数据
public void showQueue(){
// 遍历
if (isEmpty()){
System.out.println("队列空的，没有数据~~");
return;
}
// 思路：从front开始遍历，front + size()次
for (int i = front; i < front + size(); i++) {
System.out.println("arr["+i%maxSize+"]="+arr[i % maxSize]);
}
}
// 求出当前队列有效数据的个数
public int size(){
return (rear + maxSize - front) % maxSize;
}
// 显示队列的头数据， 注意不是取出数据
public int headQueue() {
// 判断
if (isEmpty()) {
throw new RuntimeException("队列空的，没有数据~~");
}
return arr[front];
}
}
import java.util.Scanner;
public class CircleArrayQueueDemo {
public static void main(String[] args) {
//测试一下
System.out.println("测试数组模拟环形队列的案例~~~");
// 创建一个环形队列
CircleArray queue = new CircleArray(4); //说明设置4, 其队列的有效数据最大是3
String key = ""; // 接收用户输入
Scanner scanner = new Scanner(System.in);//
boolean loop = true;
// 输出一个菜单
while (loop) {
System.out.println("show: 显示队列");
System.out.println("exit: 退出程序");
System.out.println("add: 添加数据到队列");
System.out.println("get: 从队列取出数据");
System.out.println("head: 查看队列头的数据");
key = scanner.nextLine(); // 接收一个字符
switch (key) {
case "show":
queue.showQueue();
break;
case "add":
System.out.println("输出一个数");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case "get": // 取出数据
try {
int res = queue.getQueue();
System.out.printf("取出的数据是%d\n", res);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case "head": // 查看队列头的数据
try {
int res = queue.headQueue();
System.out.printf("队列头的数据是%d\n", res);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case "exit": // 退出
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~");
}
}
扫一扫
456
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
