Java数据结构与算法（一）——队列

一、稀疏数组

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];
		}
}		
}