数据结构-队列

1.队列   

    队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列中没有元素时，称为空队列。

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

     队列采用的FIFO(first in first out)，新元素（等待进入队列的元素）总是被插入到链表的尾部，而读取的时候总是从链表的头部开始读取。每次读取一个元素，释放一个元素。所谓的动态创建，动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成，遍历也方便。（先进先出）

普通队列中队列满的情况可能会出现真满和假满的现象

那么解决假满方法:
1.始终让front指向0本改变,当做出队操作的时候，将队列中剩余的元素，依次往头方向移动一个位置。比较浪费时间;
2.将队列考虑:为首尾相接的环形队列，也叫循环队列。

循环队列：
对maxsize求余操作,来实现循环队列

入队：rear=(rear+1 )%maxsize

出队：front=(front+1 )%maxsize

队满条件: front=(rear+1)%maxsize

队空的条件：front = rear
循环队列需要牺牲一个存储空间。

 

2.用Java代码和数组实现队列的存储原理

package com.cym.datastructure.queue;

/**
 * Java代码实现
 * 用数组实现循环队列
 */
public class Queue<T> {
    //定义一个数组作为队列的容器
    private T[] data;
    //定义容器的最大长度
   private int maxSize;
    //定义入队的指针
    private int rear;
    //定义出队的指针
    private int front;

    /**
     * 构造方法
     *
     * @param maxSize
     */
    public Queue(int maxSize) {
        //当传入的maxSize小于时
        if (maxSize < 1) {
            maxSize = 1;
        }
        this.maxSize = maxSize;
        //初始化数组
        data = (T[]) new Object[maxSize];
        //初始化入队和出队指针
        rear = 0;
        front = 0;
    }

    /**
     * 判空
     *
     * @return
     */
    public boolean isEmpry() {
        return rear == front;
    }

    /**
     * 判断队列是否满了
     *
     * @return
     */
    public boolean isFull() {
        if (front == (rear+1)%maxSize){
            return true;
        }else {
            return false;
        }

    }

    /**
     * @param object 待入队的参数
     * @return
     */
    public boolean enQueue(Object object) {
        //要注意，队满了，则不能入队;
        if (isFull()) {
            return false;
        } else {
            //入队
            data[rear] = (T) object;
            //入队指针往后移动，因为我们这个是循环队列所以不能直接rear++；队尾指针，入队是从队尾入队的
            rear = (rear + 1) % maxSize;
            return true;
        }
    }

    /**
     * 出队操作
     *
     * @return
     */
    public T deQueue() {
        同样出队的时候，队空，则不能出队;
        if (isEmpry()) {
            return null;
        } else {
            //出队
            T obj = data[front];
            //出队指针往后移动因为我们这个是循环队列所以不能直接front++；
            front = (front + 1) % maxSize;
            return obj;
        }
    }

    /**
     *提供一些getter方法，以便外界获得该队列的属性值情况
     * @return
     */
    public T[] getData() {
        return data;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public int getRear() {
        return rear;
    }

    public int getFront() {
        return front;
    }
}

测试类

package com.cym.datastructure.queue;

/**
 * 测试类
 */
public class QueueTest {
    public static void main(String[] args) {
        //创建队列对象
        Queue<Object> queue = new Queue<>(5);
        System.out.println("队列是否是空的：" + queue.isEmpry());
        System.out.println("数据入队：");
        queue.enQueue("A");
        queue.enQueue("B");
        queue.enQueue("C");
        queue.enQueue("D");
        //虽然我们的队列的长度是5，入队四个，队列就满了，因为这是循环队列，需要牺牲一个存储空间实现
        System.out.println("队列是否是满的：" + queue.isFull());
        if (queue.isFull()) {
            System.out.println("开始出队");
            Object data = queue.deQueue();
            System.out.println("出队:" + data);
            data = queue.deQueue();
            System.out.println("出队:" + data);
            data = queue.deQueue();
            System.out.println("出队:" + data);
            data = queue.deQueue();
            System.out.println("出队:" + data);
            data = queue.deQueue();
            System.out.println("出队:" + data);
        }
        System.out.println("队列是否是空的：" + queue.isEmpry());
    }
}

输出

队列是否是空的：true
数据入队：
队列是否是满的：true
开始出队
出队:A
出队:B
出队:C
出队:D
出队:null
队列是否是空的：true