队列的基本操作概念及各种实现方式的代码

1简介

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表

顺序队列

建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置，

每次在队尾插入一个元素是，rear增1；每次在队头删除一个元素时，front增1。随着插入和删除操作的进行，队列元素的个数不断变化，队列所占的存储空间也在为队列结构所分配的连续空间中移动。当front=rear时，队列中没有任何元素，称为空队列。当rear增加到指向分配的连续空间之外时，队列无法再插入新元素，但这时往往还有大量可用空间未被占用，这些空间是已经出队的队列元素曾经占用过得存储单元。
顺序队列中的溢出现象：
（1） “下溢”现象：当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。
（2）”真上溢”现象：当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。
（3）”假上溢”现象：由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于向量空间的规模时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为”假上溢”现象。

循环队列

在实际使用队列时，为了使队列空间能重复使用，往往对队列的使用方法稍加改进：无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。自己真从MaxSize-1增1变到0，可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。除了一些简单应用之外，真正实用的队列是循环队列。
在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。队空和队满

数组实现顺序队列

public class QueueArray {
    private int size;
    private int font;
    private int rear;
    private Object[] queue;
    public QueueArray() {
        this.size=10;//初始化队列的长度
        this.font=-1;//初始化对头指针
        this.rear=-1;//初始化队尾指针
        queue =new Object[size];//初始化数组

    }
    public QueueArray(int size) {
        this.size=size;//初始化队列的长度
        this.font=-1;//初始化对头指针
        this.rear=-1;//初始化队尾指针
        queue =new Object[size];//初始化数组

    }
    //对列的入队操作
    public void inQueue(Object obj) {
        //判断对列是否已满
        if(this.rear<size) {
            rear++;
            queue[rear]=obj;
            System.out.println(obj+"入队");
        }else {
            System.out.println("对列已满");
        }
    }
    //对列的出队操作
    public Object outQueue() {
        //声明一个变量用于保存出队的数据
        Object obj=null;
        //当头指针不等于尾指针时即可认为对列不为空
        if(this.font!=this.rear) {
            font++;
            obj=queue[font];
            System.out.println(obj+"出队");

        }else {
            System.out.println("对列以空");
        }
        return obj;
    }
    //判断对列是否为空
    public boolean isQueueEmpty() {
        boolean flag=false;
        if(this.font==this.rear) {
            flag=true;
        }
        return flag;
    }
    //对列是否已满
    public boolean isfull() {
        boolean flag=false;
        if((rear+1)==size) {
            flag=true;
        }
        return false;
    }
    //对列进行遍历
    public void display() {
        //遍历钱判断是否为空
        if(!isQueueEmpty()) {
            for(int i=font+1;i<rear+1;i++) {
                System.out.println(queue[i]);
            }
        }       
    }
    public static void main(String[] args) {
        QueueArray array = new QueueArray(10);
        array.inQueue("");
        array.inQueue("");
        array.inQueue("");
        array.inQueue("");
        array.display();
        System.out.println("==============");
        array.outQueue();
        array.outQueue();
        System.out.println("==============");
        array.display();
    }

}

线性表实现

public class QNode {
    private  String data;
    private QNode next;
    public QNode() {
         this.data="";
         this.next=null;
    }
    public QNode(String data) {
        this(data,null);
    }
    public QNode(String data,QNode next) {
        this.data=data;
        this.next=next;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public QNode getNext() {
        return next;
    }
    public void setNext(QNode next) {
        this.next = next;
    }

}

package Queue;

import Data.Structer.Link;

public class LinkQueue {
    QNode head=null;
    public LinkQueue() {
        head=new QNode();
    }
    //入队
    public void inLinkQuue(String data) {
        QNode p=head;
        QNode temp = new QNode(data);
        while(p.getNext()!=null) {
            p=p.getNext();
        }
        p.setNext(temp);
        System.out.println(data+"入队");
    }//出队
    public void outLinkQueue() {
        String str="";
        if(head.getNext()!=null) {
            str=head.getNext().getData();
            head.setNext(head.getNext().getNext());
        }else {
            System.out.println("此对列已空");
            return;
        }
        System.out.println(str+"出队");
    }
    //遍历
    public void disLinkPlay() {
        QNode p=head;

        while(p.getNext()!=null) {
            System.out.println(p.getNext().getData());
            p=p.getNext();
        }
    }
    public static void main(String[] args) {
        LinkQueue link = new LinkQueue();
        link.inLinkQuue("1");
        link.inLinkQuue("2");
        link.inLinkQuue("3");
        link.inLinkQuue("4");
        link.inLinkQuue("5");
        link.inLinkQuue("6");
        link.inLinkQuue("7");
        link.inLinkQuue("8");
        link.inLinkQuue("9");
        link.inLinkQuue("10");
        System.out.println("==============");
        link.disLinkPlay();
        System.out.println("=================");
        link.outLinkQueue();
        link.outLinkQueue();
    }

}

数组实现循环队列

public class CQueue {
    Object[] data;
    int front;
    int rear;
    int size;
    public CQueue() {
        this.size=11;
        this.front=0;
        this.rear=0;
        this.data=new Object[size];
    }
    public CQueue(int size) {
        this.size=size+1;
        this.front=0;
        this.rear=0;
        this.data=new Object[size];
    }
    //判断队列是否已满
    public boolean isFull() {
        boolean flag=false;
        if((this.rear+1)%size==this.front) {
            flag=true;
        }else {
            flag=false;
        }
        return flag;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        boolean flag=false;
        if(this.rear==this.front) {
            flag=true;
        }else {
            flag=false;
        }
        return flag;
    }
    //入队操作
    public void addQueue(Object dat) {
        if(isFull()) {
            System.out.println("队列已满");
        }else {
            rear=(++rear)%this.size;
            data[rear]=dat;
            System.out.println(dat+"已入队");
        }
    }
    //出队操作
    public void outQueue() {
        if(isEmpty()) {
            System.out.println("此队列已空");
        }else {

            front=( ++front)% this.size;
            System.out.println("出队"+data[front]);
        }
    }
//  遍历
    public void diaPley() {
        int f=front;
        int r=rear;
        while(f!=r) {
            f=(++f)%this.size;
            System.out.println("遍历"+data[f]);

        }
    }
    public static void main(String[] args) {
        CQueue link = new CQueue();
        link.addQueue("1");
        link.addQueue("2");
        link.addQueue("3");
        link.addQueue("4");
        link.addQueue("5");
        link.addQueue("6");
        link.addQueue("7");
        link.addQueue("8");
        link.addQueue("9");
        link.addQueue("10");
        link.addQueue("11");
        link.diaPley();
        System.out.println("================");
        link.outQueue();
    }
}