数据结构（四）队列

1. 顺序队列实现

public class SeqQueue<T> {
    private int front; // 队头指针
    private int rear; // 队尾指针
    private T[] queueArray;
    private static final int InitLen = 5; // 数组初始长度

    // 初始化队列
    public Seq2Queue() {
        front = rear = 0;
        queueArray = (T[]) new Object[InitLen];
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return front == rear;
    }

    // 入队
    public void inQueue(T obj) {
        if ((rear + 1) % queueArray.length == front) { // 队满扩容
            T[] p = (T[]) new Object[queueArray.length * 2];
            if (rear == queueArray.length - 1) { // 情况一
                for (int i = front + 1; i <= rear; i++) {
                    p[i] = queueArray[i];
                }
            } else { // 情况二
                int j = 1;
                for (int i = front + 1; i < queueArray.length; i++, j++) {
                    p[j] = queueArray[i];
                }
                for (int i = 0; i <= rear; i++, j++) {
                    p[j] = queueArray[i];
                }
                front = 0;
                rear = queueArray.length - 1;
            }
            queueArray = p;
        }
        rear = (rear + 1) % queueArray.length;
        queueArray[rear] = obj;
    }

    // 出队
    public T outQueue() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return null;
        }
        front = (front + 1) % queueArray.length;
        return queueArray[front];
    }
    
    // 获取队头元素
    public T getHead() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return null;
        }
        return queueArray[(front + 1) % queueArray.length];
    }

    // 获取队列长度
    public int getSize() {
        return (rear - front + queueArray.length) % queueArray.length; // (2 - 0 + 5) % 5 = 2
    }

    // 遍历队列
    public void nextOrder() {
        int t = front + 1;
        for (int i = 1; i <= getSize(); i++) {
            System.out.print(queueArray[(t++) % queueArray.length] + "\t");
        }
        System.out.println();
    }

    // 清空队列
    public void clear() {
        front = rear = 0;
    }
}

2. 链式队列实现

class Node<T> {
    T data;
    Node<T> next;

    public Node() {
    }

    public Node(T data) {
        this.data = data;
    }

    public Node(T data, Node next) {
        this.data = data;
        this.next = next;
    }
}


class LinkQueue<T> {
    private int length; // 队列长度
    private Node<T> front; // 队头指针
    private Node<T> rear; // 队尾指针

    public Link1Queue() {
        length = 0;
        front = rear = new Node<>(); // 带有头节点的链表
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return front.next == null;
    }

    // 入队（写法1）
    public void inQueue(T obj) {
        rear.next = new Node<>(obj);
        rear = rear.next;
        length++; // 队列长度+1
    }

    // 出队（写法1）
    public T outQueue() {
        if (isEmpty()) {
            System.out.println("队列为空");
            return null;
        }
        T t = front.next.data;
        front.next = front.next.next;
        length--; // 队列长度-1
        if (front.next == null) { // 队列为空时
            rear = front;
        }
        return t;
    }

    // 出队（写法2）
    public T outQueue1() {
        if (isEmpty()) {
            System.out.println("队列为空");
            return null;
        }
        Node<T> p = front.next;
        front.next = p.next;
        length--; // 队列长度-1
        if (front.next == null) { // 队列为空时
            rear = front;
        }
        return p.data;
    }

    // 队列长度
    public int getSize() {
        return length;
    }

    // 队列头元素
    public T getHead() {
        if (isEmpty()) {
            System.out.println("队列为空");
            return null;
        }
        return front.next.data;
    }

    // 遍历队列
    public void nextOrder() {
        Node<T> p = front.next;
        while (p != null) {
            System.out.print(p.data + "\t");
            p = p.next;
        }
        System.out.println();
    }

    // 清空
    public void clear() {
        front.next = rear.next = null;
    }
}