1.2 队列的数组实现

队列

1. 队列是一个有序列表，其特点是先入先出，即先进队列的元素先出队列。

数组模拟队列

1. 队列只能使用一次，没有实用价值。
2. 使用数组模拟此队列时，需要定义四个属性：
   （1）arr[ ]：数组，用于存放队列中的元素
   （2）maxSize：int，用于规定队列的最大长度
   （3）front：int，arr[front+1]始终为队列的第一个元素
   （4）rear：int，arr[rear]始终表示队列中最后一个元素
3. 先进先出实现：每次添加一个元素，都添加到arr[rear+1]位置上；每次取出一个元素，都取arr[front+1]。
4. 代码：

import java.util.Scanner;

/**
 * 实现数组队列这一数据结构，测试其功能
 * @author dxt
 *
 */
public class ArrayQueue {
	public static void main(String[] args) {
		//初始化一个队列对象
		Queue<String> q = new Queue<String>(3);
		char key = ' ';	//用于接收用户输入
		Scanner scan = new Scanner(System.in);
		boolean loop = true;
		//功能菜单
		while(loop) {
			System.out.println("p(print):\t打印队列");
			System.out.println("e(exit): \t退出程序");
			System.out.println("a(add):  \t添加数据到队列");
			System.out.println("g(get):  \t从队列取数据");
			System.out.println("h(head): \t显示队列头元素");
			//接收操作指令
			key = scan.next().charAt(0);	//以字符串形式获取一个字符
			switch(key) {
			case 'p':
				q.printQueue();
				break;
			case 'a':
				System.out.println("请输入一个元素：");
				String element = scan.next();	//泛型已设为String
				q.addElement(element);
				break;
			case 'g':
				try {
					String e = q.getElement();
					System.out.println("取出的元素为：" + e);
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'h':
				try {
					String e = q.headElement();
					System.out.println("队列头元素为：" + e);
				}catch(Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				scan.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("程序运行结束。");
	}
}
/**
 * 使用对象数组模拟队列，使用了泛型
 * @author dxt
 *
 */
class Queue<E>{
	private Object[] arr;	//使用arr数组保存队列中的数据，模拟队列
	private int maxSize;	//队列的最大容量
	private int front;		//始终 指向 队列中第一个元素，即是队列中第一个元素的前一个位置，不是第一个元素
	private int rear;		//始终可以用于 表示队列中 最后一个元素，即arr[rear]
	
	//队列的构造器
	public Queue(int size) {
		maxSize = size;
		arr = new Object[maxSize];	//初始化数组
		front = -1;	//初始队列为空，设置front为-1
		rear = -1;	//初始队列为空，设置rear为-1
	}
	
	//判断队列是否已满
	public boolean isFull() {
		return rear == (maxSize-1);	//如果最后一个元素在队列最后一个位置，则已满
	}
	
	//判断队列是否为空
	public boolean isEmpty() {
		return front == rear;	
	}
	
	//向队列中添加元素
	public void addElement(E num) {
		//判断队列是否已满
		if(isFull()) {
			System.out.println("队列已满，无法添加元素");
			return;
		}
		rear++;	//最后一个元素的指向 后移
		arr[rear] = num;
	}
	
	//从队列中获取元素，既获得，又将其从队列中删除。（先进先出，获取的都是头元素）
	public E getElement() {
		//判断队列是否为空
		if(isEmpty()) {
			//抛出异常，无法正常返回数据
			throw new RuntimeException("队列为空，无法获取数据");
		}
		front++;	//使front可以直接表示头元素，隐性的删除头元素
		return (E)arr[front];	//强制转型
	}
	
	//打印队列中所有数据
	public void printQueue() {
		if(isEmpty()) {
			System.out.println("队列为空");
			return;
		}
		int first = front + 1;
		for(int i=first; i<=rear; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
	}
	
	//显示队列中第一个元素
	public E headElement() {
		if(isEmpty()) {
			throw new RuntimeException("队列为空，没有内容。");
		}
		return (E)arr[front+1];
	}
}

环形队列实现

1. 设定
   （1）arr[ ]：使用数组保存环形队列中的元素
   （2）maxSize：环形队列的最大长度
   （3）front：arr[front]始终表示队列的第一个元素
   （4）rear：arr[rear]始终表示队列中最后一个元素的后一个位置，这个位置永远是空的，因此导致了队列的最大长度为maxSize，但队列中元素个数最多为 maxSize-1 个
2. 有设定可知
   （1）当条件满足（rear+1）%maxSize = front 时，队列满。
   （2）当条件满足 rear = front 时， 队列为空。
   （3）队列中的数据个数为：（rear+maxSize-front）%maxSize。
3. 队列中每个位置都可重复使用，但队列中的空间无法被完全使用，始终会有一个位置空着。
4. 代码实现：

import java.util.Scanner;

/**
 * 使用数组模拟循环队列
 * @author dxt
 *
 */
public class CircleQueue {
	public static void main(String[] args) {
		//初始化一个队列对象
		CirQueue<String> q = new CirQueue<String>(3);
		char key = ' ';	//用于接收用户输入
		Scanner scan = new Scanner(System.in);
		boolean loop = true;
		//功能菜单
		while(loop) {
			System.out.println("p(print):\t打印队列");
			System.out.println("e(exit): \t退出程序");
			System.out.println("a(add):  \t添加数据到队列");
			System.out.println("g(get):  \t从队列取数据");
			System.out.println("h(head): \t显示队列头元素");
			//接收操作指令
			key = scan.next().charAt(0);	//以字符串形式获取一个字符
			switch(key) {
			case 'p':
				q.printQueue();
				break;
			case 'a':
				System.out.println("请输入一个元素：");
				String element = scan.next();	//泛型已设为String
				q.addElement(element);
				break;
			case 'g':
				try {
					String e = q.getElement();
					System.out.println("取出的元素为：" + e);
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'h':
				try {
					String e = q.headElement();
					System.out.println("队列头元素为：" + e);
				}catch(Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				scan.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		System.out.println("程序运行结束。");
	}
}
/**
 * 循环队列实现类
 * @author dxt
 *
 * @param <T>
 */
class CirQueue<T>{
	private Object[] arr;	//arr数组用于保存队列中的数据
	private int maxSize;	//队列的最大容量
	private int front;	//arr[front]始终表示队列中第一个元素
	private int rear;	//arr[rear]始终表示队列中最后一个元素的下一个位置
	
	//构造函数
	public CirQueue(int size) {
		maxSize = size;
		arr = new Object[maxSize];
		front = 0;	//初始front为0
		rear = 0;	//初始rear为0
	}
	
	//判断队列是否已满，满的条件：(rear+1)%maxSize = front
	public boolean isFull() {
		/*
		 * rear位置始终是没有元素的，当(rear+1)%maxSize = front时，说明arr[rear]位置是整个队列
		 * 唯一的一个没有元素的空位置。即当整个队列满时，其实队列中是有一个空位的，队列中最多同时有(maxSize-1)
		 * 个元素
		 */
		return ((rear+1)%maxSize) == front;
	}
	
	//判断队列是否为空，空的条件front=rear
	public boolean isEmpty() {
		return front == rear;
	}
	
	//向队列中添加一个元素
	public void addElement(T element) {
		//1. 判断队列是否已满
		if(isFull()) {
			System.out.println("队列已满，元素添加失败。");
			return;
		}
		//2. 未满，则添加元素到arr[rear]位置
		arr[rear] = element;
		//3. 更新rear的值
		rear = (rear+1)%maxSize;
	}
	
	//从队列中取出头元素
	public T getElement() {
		//1. 判断队列是否为空
		if(isEmpty()) {
			throw new RuntimeException("队列为空，没有数据。");
		}
		T value = (T)arr[front];	//强制转型
		front = (front+1)%maxSize;	//后移一位
		return value;	//返回数据
	}
	
	//计算队列中的元素个数
	public int length() {
		return (rear+maxSize-front) % maxSize;
	}
	
	//打印队列中的元素
	public void printQueue() {
		//1. 判断是否为空
		if(isEmpty()) {
			System.out.println("队列为空，没有数据。");
			return;
		}
		//2. 打印
		for(int i=front; i<(front+length()); i++) {
			int index = i%maxSize;
			System.out.println("arr[" + index + "]=" + arr[index]);
		}
	}
	
	//显示头元素
	public T headElement() {
		if(isEmpty()) {
			throw new RuntimeException("队列为空。");
		}
		return (T)arr[front];
	}
}