数据结构实现循环队列的两种方法

一、包含队列元素nItem方式：

package data.struct.algorithm;


//定义队列，包含五个域值
class Queuex {
    private int maxSize;
    private int[] queueArray;
    private int front;
    private int rear;
    private int nItem;

    public Queuex(int s) {
        maxSize = s;
        queueArray = new int[maxSize];
        front = 0;
        rear = -1;
        nItem = 0;
    }

    //队列尾部插入元素
    public void insert(int value) {
        if(nItem==maxSize){
            throw new RuntimeException("队列满了，不能插入数据了");
        }
        if (rear == maxSize - 1) {
            rear = -1;
        }
        queueArray[++rear] = value;
        nItem++;
    }

    //队头删除元素
    public int remove() {
        if(nItem==0){
            throw new RuntimeException("队列中没有元素了，不能进行删除操作了");
        }
        int value = queueArray[front++];
        if (front == maxSize) {
            front = 0;
        }
        nItem--;
        return value;
    }

    //查看队头元素
    public int peek() {
        return queueArray[front];
    }

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

    //判断队满
    public boolean isFull() {
        return nItem == maxSize;
    }

    //获取队列大小
    public int getSize() {
        return nItem;
    }
}

public class QueueApp {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Queuex theQueue=new Queuex(10);
        theQueue.insert(3);
        theQueue.insert(13);
        theQueue.insert(23);
        theQueue.insert(33);
        theQueue.insert(43);
        theQueue.insert(53);
        System.out.println(theQueue.peek());
        System.out.println(theQueue.remove());
        theQueue.insert(63);
        theQueue.insert(73);
        theQueue.insert(83);
        theQueue.insert(93);
//        theQueue.insert(103);
        System.out.println(theQueue.peek());
        while(!theQueue.isEmpty()){
            System.out.print(theQueue.remove()+" ");
        }
        System.out.println();
        
    }

}

二、不包含队列元素nItem方式：

package data.struct.algorithm;

//定义队列，包含四个域值，不包含队列大小nItems
//判断队空:rear==front
//判断队空:(rear+1)%maxSize==front,即队头指针在队尾指针的下一个位置
class Queuey {
    private int maxSize;
    private int[] queueArray;
    private int front;
    private int rear;

    public Queuey(int s) {
        maxSize = s;
        queueArray = new int[maxSize];
        front = 0;
        rear = 0;
    }

    // 队列尾部插入元素
    public void insert(int value) {
        if (this.isFull()) {
            throw new RuntimeException("队满");
        }
        queueArray[rear] = value;
        rear=(rear+1)%maxSize;
    }

    // 队头删除元素
    public int remove() {
        if (this.isEmpty()) {
            throw new RuntimeException("队列中没有元素了，不能进行删除操作了");
        }
        int value = queueArray[front];
        front = (front + 1) % maxSize;
        return value;
    }

    // 查看队头元素
    public int peek() {
        return queueArray[front];
    }

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

    // 判断队满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    // 获取队列大小
    public int getSize() {
        return (rear - front + maxSize) % maxSize;
    }
}

public class CopyOfQueueApp {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Queuey theQueue = new Queuey(5);
        theQueue.insert(13);
        theQueue.insert(23);
        theQueue.insert(33);
        theQueue.insert(43);
//        theQueue.insert(63);
        System.out.println(theQueue.getSize());
        System.out.println(theQueue.remove());
        System.out.println(theQueue.remove());
        theQueue.insert(63);
        theQueue.insert(73);
        System.out.println(theQueue.peek());
        while (!theQueue.isEmpty()) {
            System.out.print(theQueue.remove() + " ");
        }
        System.out.println();

    }

}

 三、用链表来实现队列

存放结点：

public class Node {

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

定义的链表的操作：

 

public class LinkList {

    private Node head;
    private Node tail;
    public LinkList(){
        head=null;
        tail=null;
    }
    public void insertLast(int data){
        Node newNode=new Node(data, null);
        if(isEmpty()){
            head=newNode;
        }
        else {
            tail.next=newNode;
        }
        tail=newNode;
    }
    public int deleteHead(){
        if(head.next==null){
            tail=null;
            return head.data;
        }
        if(head!=null){
            
            Node tempNode=head;
            head=head.next;
            return tempNode.data;
        }
        else {
            throw new RuntimeException("不能删除元素了");
        }
    }
    public boolean isEmpty(){
        return head==null;
    }
    
}

链表模拟的队列

//用的是insertLast()和deleteHead()方法，即在尾部插入，在链表头删除
public class LinkQueue {

    private LinkList linkList;
    public LinkQueue(){
        linkList=new LinkList();
    }
    public void push(int data){
        linkList.insertLast(data);
    }
    public int pop(){
        return linkList.deleteHead();
    }
    public boolean isEmpty(){
        return linkList.isEmpty();
    }
}

测试类

public class QueuqTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        LinkQueue linkQueue=new LinkQueue();
        linkQueue.push(10);
        linkQueue.push(20);
        linkQueue.push(30);
        linkQueue.push(40);
        System.out.println(linkQueue.pop());
    }
}