队列相关介绍与实现

一、基本介绍

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

二、数组实现

/**
 * 创建node节点
 */
public class Node {

	private int id;

	public Node(int value) {
		this.id = value;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
}

/**
 * 数组实现队列的工具方法
 */
class CircleArrayUtil {
	// 表示数组的最大容量
	private int maxSize; 
	// front 就指向队列的第一个元素
	private int front;
	// rear 指向队列的最后一个元素的后一个位置
	private int rear;
	// 该数据用于存放数据
	private Node[] arr;
	
	public CircleArray(int arrMaxSize) {
		// 实际空间比逻辑空间大一个
		maxSize = arrMaxSize + 1;
		arr = new Node[maxSize];
	}

	// 判断队列是否满
	public boolean isFull() {
		return (rear  + 1) % maxSize == front;
	}
	
	// 判断队列是否为空
	public boolean isEmpty() {
		return rear == front;
	}
	
	// 添加数据到队列
	public void addQueue(Node n) {
		if (isFull()) {
			System.out.println("队列已满");
			return;
		}
		arr[rear] = n;
		rear = (rear + 1) % maxSize;
	}
	
	// 获取队列的数据
	public Node getQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列已空");
		}
		Node value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}
	
	// 显示队列的所有数据
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列空的，没有数据~~");
			return;
		}

		for (int i = front; i < front + size() ; i++) {
			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize].getId());
		}
	}
	
	// 求出当前队列有效数据的个数
	public int size() {
		return (rear + maxSize - front) % maxSize;   
	}
}

二、链表实现

• 链表是以节点的方式来存储，是链式存储，每个节点包含 data 域、next 域；链表的各个节点不一定是连续存储。
• 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

1. 单向链表实现队列效果

/**
 * 每个Node对象就是一个节点
 */
class Node {
	private int id;
	
	public Node next; //指向下一个节点
	
	public Node(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
}

/**
 * 定义SingleLinkedList管理节点
 */
class SingleLinkedList {

	// 初始化一个头节点,头节点不要动,不存放具体的数据
	private Node head = new Node(0);

	// 获得第一个节点,并将第一个节点去除
	public Node getFirstNode() {
		Node temp = head.next;
		if (temp == null) {
			System.out.println("链表为空");
			return null;
		}
		head.next = temp.next;
		return temp;
	}

	// 添加节点到单向链表(不考虑id顺序)
	public void add(Node node) {
		// temp辅助遍历
		Node temp = head;
		// 遍历链表,找到最后
		while (true) {
			// 找到链表的最后
			if (temp.next == null) {//
				break;
			}
			// 如果没有找到最后,将temp后移
			temp = temp.next;
		}
		// 当退出while循环时,temp就指向了链表的最后,将temp节点的next指向新的节点
		temp.next = node;
	}

	// 显示链表
	public void list() {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		Node temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp.getId());
			temp = temp.next;
		}
	}

	// 显示链表大小
	public int size() {
		if (head.next == null) {
			System.out.println("链表为空");
			return 0;
		}
		int count = 0;
		Node temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp.getId());
			temp = temp.next;
			count++;
		}
		return count;
	}

	// 拓展：添加节点到单向链表(考虑id顺序)
	public void addByOrder(Node node) {
		Node temp = head;
		while (true) {
			if (temp.next == null) {// 说明temp已经在链表的最后
				break;
			} else if (temp.next.getId() >= node.getId()) { // 位置找到,就在temp的后面插入
				break;
			}
			temp = temp.next;
		}
		// 插入到链表中,temp的后面
		node.next = temp.next;
		temp.next = node;
	}

	// 拓展：删除节点
	public void del(int id) {
		Node temp = head;
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.getId() == id) {
				temp.next = temp.next.next;
			}
			temp = temp.next;
		}
	}

}

2. 双向链表实现队列效果

/**
 * 每个Node对象就是一个节点
 */
class Node {
	private int id;
	
	public Node next; 	//指向下一个节点
	
	public Node pre;	//指向上一个节点
	
	public Node(int id) {
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
}

/**
 * 创建一个双向链表的类
 */
class DoubleLinkedList {

	// 初始化一个头节点,不存放具体的数据
	private Node head = new Node(0);

	// 获得第一个节点,并将第一个节点去除
	public Node getFirstNode() {
		Node temp = head.next;
		if (temp == null) {
			System.out.println("链表为空");
			return null;
		}
		head.next = temp.next;
		if (temp.next != null) {
			temp.next.pre = temp.pre;
		}
		return temp;
	}

	// 遍历双向链表
	public void list() {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		Node temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp.getId());
			temp = temp.next;
		}
	}

	// 添加一个节点到双向链表的最后
	public void add(Node node) {
		Node temp = head;
		while (true) {
			if (temp.next == null) {//
				break;
			}
			temp = temp.next;
		}
		temp.next = node;
		head.pre = temp;
	}

	// 拓展：从双向链表中删除一个节点
	public void del(int id) {
		if (head.next == null) {
			System.out.println("链表为空，无法删除");
			return;
		}

		Node temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			if (temp.getId() == id) {
				temp.pre.next = temp.next;
				// 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
				if (temp.next != null) {
					temp.next.pre = temp.pre;
				}
			}
			temp = temp.next; // temp后移，遍历
		}
	}

}

3. 小结

• 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
• 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除。