java与数据结构(8)---java实现链队列

链队列

实际上就是单链表，只是规定了删除在队头进行，添加在队尾进行。

链队列代码结构

package list.queue;

　　public interface Queuable<T>;

　　public class QueueNode<T>;

　　public class LinkedQueue<T>;

package list;

　　public class TestLinkedQueue;

链队列公共接口

package list.queue;

public interface Queuable<T> {

    public int length();

    public boolean destroyQueue();

    public void clear();

    public boolean isEmpty();

    public T getHead();

    public boolean add(T element);

    public T remove();

}

链队列节点类

package list.queue;

public class QueueNode<T> {
    private T data;
    private QueueNode next;

    QueueNode() {
        this(null);
    }
    
    QueueNode(T data) {
        this(data,null);
    }

    QueueNode(T data, QueueNode<T> next) {
        this.data = data;
        this.next = next;
    }

    public QueueNode<T> getNext() {
        return this.next;
    }

    public T getData() {
        return this.data;
    }

    public void setNext(QueueNode<T> next) {
        this.next = next;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String toString() {
        return getData().toString();
    }
    
}

链队列实现类

//**************************************************************************
//*队列之链式存储结构链队列-JAVA实现
//*@author Nora-Xie
//*@time 2013-10-07PM22:00
//**************************************************************************

package list.queue;

import list.queue.QueueNode;
import list.queue.Queuable;

//链队列实际就是单链表，只不过是限定了其删除在队头，插入在队尾而已
public class LinkedQueue<T> implements Queuable<T> {
    private QueueNode<T> front,rear;

    public LinkedQueue() {
        this(null);
    }

    public LinkedQueue(T element) {
        if(element == null) {
            front = new QueueNode<T>(null);
            rear = front;
        }else {
            rear = new QueueNode<T>(element);
            front = new QueueNode<T>(null,rear);
        }
    }

    public int length(){
        if(isEmpty()) return 0;
        int k = 1;
        QueueNode<T> temp = front.getNext();
        while(temp != rear) {
            k++;
            temp = temp.getNext();
        }
        return k;
    }

    public boolean destroyQueue() {
        return false;
    }

    public void clear() {
        if(isEmpty()) return;
        while(front.getNext() != rear) {
            remove();
        }
        remove();
    }

    public boolean isEmpty() {
        return front == rear;
    }

    public T getHead() {
        if(isEmpty()) return null;
        return front.getNext().getData();
    }

    public boolean add(T element) {
        if(element == null) return false;
        QueueNode<T> temp = front;
        rear.setNext(new QueueNode<T>(element));
        rear = rear.getNext();
        return true;
    }

    public T remove() {
        if(isEmpty()) return null;
        T element = front.getNext().getData();
        if(length() == 1) 
            rear = front;
        else{
            front.setNext(front.getNext().getNext());
        }
        return element;
    }

    public String toString() {
        if(isEmpty()) return "[ ]";
        StringBuffer sb = new StringBuffer("[ ");
        QueueNode<T> temp = front.getNext();
        while(temp != rear) {
            sb.append(temp+" ");
            temp = temp.getNext();
        }
        sb.append(temp+" ");
        sb.append("]");
        return sb.toString();
    }

}

链队列测试类

package list;

import list.queue.LinkedQueue;
import list.queue.Queuable;
import list.queue.QueueNode;

public class TestLinkedQueue {
    public static void main(String[] args) {
        Queuable<String> queue = new LinkedQueue<String>("A");
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        queue.add("B");
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        System.out.println("the removint element="+queue.remove());
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        queue.add("C");
        queue.add("D");
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        queue.clear();
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        System.out.println("queue is empty?  "+queue.isEmpty());
        queue = new LinkedQueue<String>("a");
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        queue.add("b");
        queue.add("c");
        queue.add("d");
        queue.add("e");
        queue.add("f");
        queue.add("g");
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        System.out.println("queue's head is ["+queue.getHead()+"]");
        queue.remove();
        System.out.println("queue="+queue+"   queue.length="+queue.length());
        System.out.println("queue's head is ["+queue.getHead()+"]");
    }
}