队列- 链式存储-Java实现

package com.wrh.lab.dataStructure.stackAndQueue;

/**
 * the interface of queue
 * @author wrh
 *
 * @param <E>
*/
public interface Queue<E> {

/**
     * enqueue the element
     * @param element
*/
public void enqueue(E element);

/**
     * 
     * @return the dequeue element
*/
public E dequeue(); 

/**
     * get the first element of the queue
     * @return the first element of the queue
*/
public E getFirstVal();

/**
     * 
     * @return true for empty and false for not empty
*/
public boolean isEmpty();

/**
     * clear the queue
*/
public void clear();
}

 

package com.wrh.lab.dataStructure.stackAndQueue;

public class QueueNode<E> {

private E element;
private QueueNode<E> next;

/**
     * 
*/
public QueueNode() {
        element = null;
        next = null;
    }

public QueueNode(E element, QueueNode<E> next) {
this.element = element;
this.next = next;
    }

public E getElement() {
return element;
    }

/**
     * @param element
*/
public void setElement(E element) {
this.element = element;
    }

public QueueNode<E> getNext() {
return next;
    }

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

 

package com.wrh.lab.dataStructure.stackAndQueueImpl;

/**
 * @author wrh
 * The implement of circular linked queue
*/
import com.trs.lab.dataStructure.stackAndQueue.Queue;
import com.trs.lab.dataStructure.stackAndQueue.QueueNode;

public class CircularLinkedQueueImpl<E> implements Queue<E> {
private QueueNode<E> front;
private QueueNode<E> rear;

/**
     * constructor
*/
public CircularLinkedQueueImpl() {
        front = rear = null;
    }

    @Override
public void enqueue(E element) {
if (null != rear) {    // if the queue is not empty
            rear.setNext(new QueueNode(element,null));
            rear = rear.getNext();
        } else {
            front = rear = new QueueNode(element, null);
        }
    }

    @Override
public E dequeue() {
if (isEmpty()) {
            System.out.println("the queue is empty!");
return null;
        } else {
            E e = front.getElement();
            front = front.getNext();
return e;
        }
    }

    @Override
public E getFirstVal() {
if (isEmpty()) {
            System.out.println("the queue is empty");
return null;
        } else {
return front.getElement();
        }
    }

    @Override
public boolean isEmpty() {
return null == front;
    }

    @Override
public void clear() {
        front = rear = null;
    }

public static void main(String[] args) {
        Queue<Integer> q = new CircularLinkedQueueImpl<Integer>();
        q.dequeue();
        q.enqueue(1);
        q.enqueue(2);
        q.enqueue(3);
        q.enqueue(4);
        System.out.println(q.getFirstVal());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());
        System.out.println(q.dequeue());


    }

}

转载于:https://www.cnblogs.com/wrh526/archive/2012/02/16/2354617.html