一、稀疏数组
package sparseArray;
public class SparseArray {
public static void main(String[] args) {
//创建一个原始的二维数组
//0:表示没有棋子;1:表示黑子;2:表示白子
int chessArr1[][] = new int[5][5];
chessArr1[1][2] = 1;
chessArr1[2][3] = 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 < 5; i++) {
for (int j = 0; j < 5; j++) {
if (chessArr1[i][j]!=0) {
sum++;
}
}
}
//2、创建对应的稀疏数组
int sparseArr[][] = new int[sum+1][3];
//给稀疏数组赋值
sparseArr[0][0] = 5;
sparseArr[0][1] = 5;
sparseArr[0][2] = sum;
//遍历二维数组,将非零值存放到稀疏数组中
int count = 0; //用于记录是第几个非零数据
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; 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]);
}
//将稀疏数组转换为二维数组
int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
for (int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
for(int[] row : chessArr2){
for(int data : row){
System.out.printf("%d\t", data);
}
System.out.println(); //每打一行换一行
}
}
}
二、队列
package Queue;
import java.util.Scanner;
public class ArrayQueueDemo {
public static void main(String[] args) {
//创建一个队列
ArrayQueueDemo arr = new ArrayQueueDemo();
ArrayQueue queue = arr.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("g(get)获取队列数据");
System.out.println("a(add)添加数据到队列");
System.out.println("h(head)显示队列头数据");
key = scanner.next().charAt(0); //接收一个字符
switch (key) {
case 's':
queue.showArr();
break;
case 'a':
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g':
try {
int res = queue.getQueue();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
int h = queue.head();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出");
}
//编写一个ArrayQueue的类
class ArrayQueue{
//先创建三个变量,数组最大容量,队列头,队列尾和一个数组
private int maxSize;
private int front;
private int rear;
private int[] arr; //该数组用于存放数据,模拟队列
// 1、return 语句的作用
// (1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。
// (2) return 返回一个值给调用该方法的语句,返回值的数据类型必须与方法的声明中的返回值的类型一致。
// (3) return后面也可以不带参数,不带参数就是返回空,其实主要目的就是用于想中断函数执行,返回调用函数处。
// 2、break语句的作用
// (1)break在循环体内,强行结束循环的执行,也就是结束整个循环过程,不在判断执行循环的条件是否成立,直接转向循环语句下面的语句。
// (2)当break出现在循环体中的switch语句体内时,其作用只是跳出该switch语句体。
//先创建构造器,输入参数maxSize,定义rear,front,arr
public ArrayQueue(int arrMaxSize){
maxSize = arrMaxSize;
front = -1; //指向队列头部,指向队列前的一个位置
rear = -1; //指向队列尾,指向队列尾的数据
arr = new int[maxSize];
}
//存数据,先判断队列是否满
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++;
arr[rear] = n;
}
//从队列取数据
public int getQueue(){
if(isEmpty()){
throw new RuntimeException("队列空,不能取数据");
}
front++;
return arr[front];
}
//显示队列的所有数据
public void showArr(){
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 head(){
if(isEmpty()){
throw new RuntimeException("队列空,不能取数据");
}
return arr[front+1];
}
}
}
数组模拟环形队列
package Queue;
import java.util.Scanner;
public class CircleArrayQueue {
public static void main(String[] args) {
//创建一个队列
CircleArrayQueue arr = new CircleArrayQueue();
CircleArray queue = arr.new CircleArray(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("g(get)获取队列数据");
System.out.println("a(add)添加数据到队列");
System.out.println("h(head)显示队列头数据");
key = scanner.next().charAt(0); //接收一个字符
switch (key) {
case 's':
queue.showArr();
break;
case 'a':
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g':
try {
int res = queue.getQueue();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'h':
try {
int h = queue.head();
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出");
}
class CircleArray{
//先创建三个变量,数组最大容量,队列头,队列尾和一个数组
private int maxSize;
private int front;
private int rear;
private int[] arr; //该数组用于存放数据,模拟队列
//先创建构造器,输入参数maxSize,定义rear,front,arr
public CircleArray(int arrMaxSize){
maxSize = arrMaxSize;
front = 0; //指向队列头部,指向队列的第一个位置
rear = 0; //指向队列尾,指向队列尾的后一个数据
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++;
}
//从队列取数据
public int getQueue(){
if(isEmpty()){
throw new RuntimeException("队列空,不能取数据");
}
int value = arr[front];
front = (front+1) % maxSize;
//front后移的时候考虑取模,假如front在队列最后一个位置,后移之后是第一个位置,直接加一会报错,需要加一后取模才能回到第一个位置
return value; //return之后,直接跳出方法,后面方法中的代码不执行
}
//计算队列中有效数据的个数
public int size(){
return (rear + maxSize - front) % maxSize;
//如果rear在front后面,则有效个数是rear-front,如果rear在front前面,则有效个数是(rear + maxSize - front) % maxSize
}
//显示队列的所有数据
public void showArr(){
if(isEmpty()){
System.out.println("队列空,不能取数据");
return;
}
front = front % maxSize;
for (int i = front; i < (front + size()); i++) {
System.out.printf("arr[%d]=%d\n",i,arr[i]);
}
}
//显示队列头数据
public int head(){
if(isEmpty()){
throw new RuntimeException("队列空,不能取数据");
}
return arr[front];
}
}
}