1、稀疏数组
当一个数组中大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组。
1、处理方法:
- 记录数组一共有几行几列,有多少个不同的值
- 把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kipbcZ4h-1590731763253)(C:%5CUsers%5CAdministrator%5CPictures%5CSnipaste%5Cxiaobear_2020-05-27_22-59-32.png)]
2、应用实例
使用稀疏数组,来保留类似前面的二维数组(棋盘、地图等等)
把稀疏数组存盘,并且可以从新恢复原来的二维数组数
整体思路分析
二维数组转稀疏数组的思路:
- 遍历原始二维数组,得到有效数据个数sum
- 根据sum就可以创建稀疏数组sparseArr int[sum+1] [3]
- 将二维数组的有效数据存入到稀疏数组
稀疏数组转二维数组的思路:
- 先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组,比如上面的chessArr2 = int[11] [11]
- 在读取稀疏数组后几行数据,并赋给原来的二维数组
3、代码实现
public class SparseArray {
public static void main(String[] args) {
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 i : row) {
System.out.print(i+" ");
}
System.out.println();
}
/**
* 二维数组转稀疏数组
* 1. 遍历原始二维数组,得到有效数据个数sum
* 2. 根据sum就可以创建稀疏数组sparseArr int[sum+1] [3]
* 3. 将二维数组的有效数据存入到稀疏数组
*/
int sum=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11 ; j++) {
if (chessArr1[i][j] != 0) {
sum++;
}
}
}
//创建相应的稀疏数组
int sparseArr[][] = new int[sum + 1][3];
//给稀疏数组赋值
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
/**
* 遍历二维数组,将非0的值存入到sparseArr
* count用于记录第几个非0的数据
*/
int count = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11 ; j++) {
if (chessArr1[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];
}
}
}
/**
* 输出稀疏数组
*/
System.out.println();
System.out.println("-----得到的稀疏数组为----");
for (int i = 0; i <sparseArr.length ; i++) {
System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
}
System.out.println();
/**
* 稀疏数组转二维数组
* 1. 先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组,
* 比如上面的chessArr2 = int[11] [11]
* 2. 在读取稀疏数组后几行(第二行)数据,并赋给原来的二维数组
*/
int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i <sparseArr.length ; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][0]] = sparseArr[i][2];
}
for (int[] row : chessArr2) {
for (int i : row) {
System.out.print(i+" ");
}
System.out.println();
}
}
}
2、队列
队列是一个有序列表,可以用数组或是链表来实现。
遵循先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取出
1、数组模拟队列
思路分析
- 将尾指针往后移:rear+1 , 当front == rear 【空】
- 若尾指针 rear 小于队列的最大下标 maxSize-1,则将数据存入 rear所指的数组元素中,否则无法存入数据。 rear == maxSize - 1[队列满]
代码实现
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 result = queue.getQueue();
System.out.printf("取出的数据是:%d\n",result);
}catch (Exception e){
System.out.println(e.getMessage());
}
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("程序退出");
}
}
/**
* 编写ArrayQueue类
* maxSize 数组最大容量
* front 队列头
* rear 队列尾
* arr 存放数据,模拟队列
*/
class ArrayQueue{
private int maxSize;
private int front;
private int rear;
private int[] arr;
/**
* 创建队列的构造器
* @param arrMaxSize
* front 指向队列头部,分析出front是指向队列头的前一个位置
* rear 指向队列尾部,指向队列尾的数据(最后一个数据)
*/
public ArrayQueue(int arrMaxSize) {
maxSize = arrMaxSize;
arr = new int[maxSize];
front = -1;
rear = -1;
}
/**
* 判断队列是否为满
* @return
*/
public boolean isFull(){
return rear == maxSize - 1;
}
/**
* 判断队列是否为空
* @return
*/
public boolean isEmpty(){
return rear == front;
}
/**
* 添加数据到队列
*/
public void addQueue(int n){
if(isFull()){
System.out.println("队列已满,不能加入数据");
return;
}
rear++;
arr[rear] = n;
}
/**
* 获取队列的数据,出队列
* @return
*/
public int getQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空,不能取数据");
//System.out.println("数据为空");
}
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];
}
}
**存在的问题:**数组只能用一次,没有做成一个环形队列
2、数组模拟环形队列
思路分析:
- front变量的含义做一个调整:front指向队列的第一个元素,也就是说arr[front]就是队列第一个元素,front = 0(初始值)
- rear变量的含义做一个调整:rear指向队列的最后一个位置,空出一个空间作为约定 rear = 0(初始值)
- 队列满,条件是:(rear+1)% maxSize = front
- 队列空的条件:rear == front
- 有效数据个数:(rear+maxSize-front)%maxSize
代码实现
public class CircleArray {
public static void main(String[] args) {
CircleArrayD queue = new CircleArrayD(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 result = queue.getQueue();
System.out.printf("取出的数据是:%d\n",result);
}catch (Exception e){
System.out.println(e.getMessage());
}
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("程序退出");
}
}
/**
* 编写ArrayQueue类
* maxSize 数组最大容量
* front 队列头
* rear 队列尾
* arr 存放数据,模拟队列
*/
class CircleArrayD{
private int maxSize;
private int front;
private int rear;
private int[] arr;
/**
* 创建队列的构造器
* @param arrMaxSize
* front 指向队列头部,分析出front是指向队列头的前一个位置
* rear 指向队列尾部,指向队列尾的数据(最后一个数据)
*/
public CircleArrayD(int arrMaxSize) {
maxSize = arrMaxSize;
arr = new int[maxSize];
//front = 0;
// rear = 0;
}
/**
* 判断队列是否为满
* @return
*/
public boolean isFull(){
return (rear+1) % maxSize == front;
}
/**
* 判断队列是否为空
* @return
*/
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;
}
/**
* 获取队列的数据,出队列
* @return
*/
public int getQueue(){
if (isEmpty()){
throw new RuntimeException("队列为空,不能取数据");
}
/**
* 分析出front指向队列的第一个元素
* 1.先把front对应的值保存到一个临时变量
* 2.front后移
* 3.将临时变量返回
*/
int value = arr[front];
front = (front + 1)%maxSize;
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];
}
}