浅谈Java中的数据结构（队列）

借助Java语言用数组和链表实现队列

 

Part 1 用链表实现队列

QueueNode类是用来表示一个链表节点的类，QueueLinked是链表实现的队列，

其中front是对首指针，rear是队尾指针，队首出队，队尾入队。

package test;
/**
 * 链表节点类
 */
class QueueNode {
    Object data; // 节点存储的数据
    QueueNode next; // 指向下个节点的指针

    public QueueNode() {
        this(null, null);
    }
    public QueueNode(Object data) {
        this(data, null);
    }
    public QueueNode(Object data, QueueNode next) {
        this.data = data;
        this.next = next;
    }
}
/**
 * 单向链表实现的队列
 */
public class Manager {
    QueueNode front; // 队首指针
    QueueNode rear;  // 队尾指针

    public Manager() {
        this.rear = null;
        this.front = null;
    }
    /**
     * 将一个对象追加到队列的尾部
     */
    public void enqueue(Object obj) {
        //如果队列是空的
        if (rear == null && front == null) {
            rear = new QueueNode(obj);
            front = rear;
        } else {
            QueueNode node = new QueueNode(obj);
            rear.next = node;
            rear = rear.next;
        }
    }
    /**
     * 队首对象出队
     * @return 出队的对象，队列空时返回null
     */
    public Object dequeue() {
        //如果队列空
        if (front == null) {
            return null;
        }
        //如果队列中只剩下一个节点
        if (front == rear && rear != null) {
            QueueNode node = front;
            rear = null;
            front = null;
            return node.data;
        }
        Object obj = front.data;
        front = front.next;
        return obj;
    }

    public static void main(String[] args) {
        //遍历输出
        Manager q = new Manager();
        q.enqueue("。");
        q.enqueue("。。");
        q.enqueue("。。。");
        q.enqueue("。。。。");
        for (int i = 0; i < 4; i++) {
            System.out.println(q.dequeue());
        }
    }
}

 Part 2 用数组实现队列

package test;
/**
 * 顺序存储结构队列
 */
public class Manager {
    private static final int MAX_SIZE = 100;
    private Object[] queue;        //队列
    private int front;                     //头指针
    private int rear;                      //尾指针
    private int length;                //队列初始化长度  
    //初始化队列
    private void init(){
        queue = new Object[this.length + 1]; 
        front = rear = 0;
    }
    //入队
    public void put(Object object) throws Exception{
        if(isFull()){
            throw new Exception("入队失败!队列已满!");
        }
        queue[rear] = object;
        rear = (rear + 1) % queue.length;
    }
    //出队
    public Object get() throws Exception{
        if(isEmpey()){
            throw new Exception("出队失败!队列为空!");
        }
        Object object = queue[front];
        queue[front] = null;  //释放对象
        front = (front + 1) % queue.length;
        return object;
    }
    //清空队列
    public void clear(){
        queue = null;
        queue = new Object[this.length];
    }
    //获得队列当前大小
    public int size(){
        return (rear - front + queue.length ) % queue.length;
    }
    //判断队列是否已满
    public boolean isFull(){
        return (rear + 1) % queue.length == front;
    }
    //判断队列是否为空
    public boolean isEmpey(){
        return front == rear;
    }
    public Manager(){
        this.length = MAX_SIZE;
        init();
    }
    public Manager(int length){
        this.length = length;
        init();
    }

    public static void main(String[] args) {
        Manager queue = new Manager(5);
        char[] data = new char[]{'1','2','3','4','5'};
        try {
            for (int i = 0; i < data.length; i++) {
                System.out.println("入队数据:" + data[i]);
                queue.put(data[i]);
            }
            System.out.println("队大小:" + queue.size());
            System.out.println("---------------------");
            while(!queue.isEmpey()){
                System.out.println("出队数据:" + queue.get());
            }
            System.out.println("队空否?	" + queue.isEmpey());
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}