稀疏数组和数组模拟队列

稀疏数组（sparsearray）

实际需求
使用二维数组记录五子棋盘，0表示没有棋子，1表示黑方所下棋子，2表示白方所下棋子。如图

因为存放棋盘的二维数组绝大部分默认值为0引出稀疏数组的出现

稀疏数组
当一个数组中大部分元素为同一元素时，可以使用稀疏数组来存放该数组。
稀疏数组的处理方法

1. 记录数组一共有几行几列几个不同的值
2. 把具有不同值得元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

二维数组转稀疏数组的思路

1. 遍历原始二维数组，得到有效数据的个数sum
2. 根据sum就可以创建稀疏数组sparseArr int[sum +1][3]
3. 将二维数组的有效数据存入稀疏数组

稀疏数组转原始的二维数组的思路

1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，
2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

代码实现

public class SpareArray {

	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.printf("%d\t",data);
			}
			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++;
				}
			}
		}
		
		// 创建对应的稀疏数组
		int sparseArr[][] = new int[sum+1][3];
		//给稀疏数组赋值
		sparseArr[0][0] = 11;
		sparseArr[0][1] = 11;
		sparseArr[0][2] = sum;
		
		// 遍历二维数组，将非0的值存放到sparseArr中
		int count = 0; // 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.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可
		 */
		
		// 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.printf("%d\t",data);
			}
			System.out.println();
		}
	}

}

数组模拟队列

队列

1. 队列是一个有序列表，可以用数组或是链表来实现
2. 遵循先入先出的原则

数组模拟队列思路

1. 数组本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下，其中maxSize是该队列的最大容量
   
2. 因为队列的输入、输出分别从前后端来处理，因此需要两个变量front和rear分别记录队列前后端的下标，front会随着数据输出而改变，而rear则是随着数据输入而改变，如图所示
3. 当我们将数据存入队列时成为“addQueue”，addQueue的处理需要两个步骤，思路分析
   1）将尾指针往后移：rear+1,当front == rear表示空
   2）若尾指针rear小于队列的最大下标maxSIze-2，则将数据存入rear所指的数组元素中，否则无法存入数据，rear = = maxSize - 1[队列满]

代码实现

import java.util.Scanner;

import javax.management.RuntimeErrorException;

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'e':   // 退出程序
				scanner.close();
				loop = false;
				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) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case'h':  //查看队列头的数据
				try {
					int res = queue.headQueue();
					
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			default:
				break;
			}
			
			
		}
		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[maxSize];
			front = -1; //指向队列头部，分析出front是指向队列头的前一个位置
			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++; //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];
		}
}