数据结构--队列

1 队列是只允许在一段进行插入操作，在另外一端进行删除操作的线性表。
1.1顺序存储结构。约定front指针指向头元素的前一个元素，rear指向队尾元素。

public class QueueCustom<E> {

	/**
	 * 队列最大节点数
	 */
	private static final Integer MAX_SIZE = 100;

	/**
	 * 存储数据域
	 */
	private Object[] data;

	/**
	 * 指向队头元素的前一个元素
	 */
	private Integer front;

	/**
	 * 指向队尾元素
	 */
	private Integer rear;

	/**
	 * 
	 */
	public QueueCustom() {
		front = -1;
		rear = -1;
		data = new Object[MAX_SIZE];
	}

	/**
	 * 入列操作
	 * 
	 * @param x
	 */
	public void EnQueue(E x) {
		if ((rear + 1) % MAX_SIZE == front) {
			System.out.println("队列已满");
		} else {
			rear = (rear + 1) % MAX_SIZE;
			data[rear] = x;
		}
	}

	/**
	 * 出列
	 * 
	 * @return 出列的数据域
	 */
	@SuppressWarnings("unchecked")
	public E DeQueue() {
		if (rear != front) {
			front = (front + 1) % MAX_SIZE;
			return (E) data[front];
		} else {
			return null;// 队列为空
		}
	}

	/**
	 * 获取出列的数据域，不移动尾指针域
	 * 
	 * @return 出列的数据域
	 */
	@SuppressWarnings("unchecked")
	public E getTopQueue() {
		if (rear != front) {
			int temp;
			temp = (front + 1) % MAX_SIZE;
			return (E) data[temp];
		} else {
			return null;
		}
	}

	/**
	 * 判断是否为空
	 * 
	 * @return 为空返回true，不为空返回false
	 */
	public boolean isEmpty() {
		if (rear == front) {
			return true;
		} else {
			return false;
		}
	}

	public static void main(String[] args) {
		QueueCustom sb = new QueueCustom();
		sb.EnQueue(1);
		sb.EnQueue(2);
		sb.EnQueue(3);
		sb.EnQueue(4);
		sb.EnQueue(5);
		System.out.println(sb.DeQueue());
		System.out.println(sb.DeQueue());
		System.out.println(sb.DeQueue());
		System.out.println(sb.DeQueue());
		System.out.println(sb.DeQueue());
	}
}

1.2 链接存储结构
定义节点结构与单链表类似，一个数据域，一个指向下一个节点的指针。

/**
 * node3 <= node2 <= node1 <= node0
 * ^                          ^
 * |                          |
 * tailNode                 headNode
 *
 * @Author: ShipTang
 * @Description: 队列重写
 * @Date: 2021/8/12 14:48
 */
public class QueueRewrite<E> {

    /**
     * 空节点，给头指针初始化指向使用，防止出现空指针
     */
    private final Node<E> emptyNode = new Node<>(null);

    private Node<E> headNode;

    private Node<E> tailNode;

    public QueueRewrite() {
        //初始化头节点和尾节点
        this.headNode = emptyNode;
        this.tailNode = emptyNode;
    }

    public void push(E e) {
        Node<E> newNode = new Node<>(e, null);
        this.tailNode.nextNode = newNode;
        this.tailNode = newNode;
    }

    public E pull() {
        Node<E> pullNode = this.headNode.nextNode;
        this.headNode.nextNode = pullNode.nextNode;
        //切断节点与其他节点的联系
        pullNode.nextNode = null;
        return pullNode.e;
    }

    public void printQueue() {
        Node<E> node = this.headNode.nextNode;
        while (node != null) {
            System.out.println(node.e);
            node = node.nextNode;
        }
    }

    private static class Node<E> {

        private E e;

        private Node<E> nextNode;

        public Node(E e) {
            this.e = e;
        }

        public Node(E e, Node<E> nextNode) {
            this.e = e;
            this.nextNode = nextNode;
        }
    }
}