数据结构之队列的基本实现

---

队列

队列和栈一样都是一种特殊的线性表。队列的基本操作是入队，它是在队列尾部插入一个元素，和出队，删除并返回在队列头部的元素。因为在队列尾插入，在队列头删除，所以队列的工作模式是先进先出，与栈(先进后出)是相反的。下图为队列的基本结构图。

队列的实现

和栈一样，队列也可以通过数组和链表来实现。上一篇栈是使用链表来实现的，这里队列就用数组来实现。使用数组实现队列往往是做成循环队列，不浪费资源。

属性及构造方法

实现队列的方法之前，还需要定义基本的队列属性和构造方法。

• 因为基于数组实现，所以定义数组肯定是必不可少的。
• 定义两个指针头指针、尾指针，分别指向队列头和队列尾的下标。
• 定义一个size属性来统计队列中数据的个数。
• 定义一个arrLen来保存队列数组的长度，默认队列数组长度为10。
• 无参构造方法，队列数组默认长度为10。
• 指定队列长度的构造方法。

代码部分

//队列数组
public Object[] arr;
//头指针
public int front = 0;
//尾指针
public int rear = 0;
//队列中元素个数
public int size = 0;
//队列数组长度默认为10
public int arrLen = 10;

//构造方法
public StrQueue() {
    //无参构造方法，队列数组默认长度设置为10
    arr = new Object[arrLen];
}

//指定队列长度的构造方法
public StrQueue(int arrLen) {
    this.arrLen = arrLen;
    arr = new Object[arrLen];
}

isEmpty()方法

isEmpty()方法判断队列是否为空，如果队列中元素的数量等于0即队列为空。

public Boolean isEmpty(){
   	return size == 0;
}

getSize()方法

getSize()方法返回队列中元素数量，在属性中定义了一个队列元素数量的属性size，所以这里直接返回size属性即可。

public Integer getSize(){
    return size;
}

isFull()方法

isFull()方法，判断队列是否已满，队列头和队列尾相等，即队列已满。

public Boolean isFull(){
    //队列头和队列尾相等，即队列已满
    return (rear + 1) % arrLen == front;
}

traverse()方法

traverse()方法遍历队列，只有队列头结点和尾结点不相等，就可以一直输出。

代码实现

public void traverse(){
    //先找到队列头，从队列头部开始遍历
    int i = front;
    while (i != rear){
        System.out.println("编程小马：" + arr[i]);
        //移动队列头
        i = (i + 1) % arrLen;
    }
}

add(Object data)方法

add(Object data)方法入队，即添加元素到队列。入队之前需要先判断一下队列是否已满；在队列尾插入元素，即直接在队列尾指针位置插入，改变尾指针的位置即可。

代码实现

/**
 * 添加元素到队列，队列添加元素都是添加在队列尾部
 * @param data 添加的元素值
 * @return Boolean
 */
public Boolean add(Object data){
    //判断队列是否满了
    if(isFull()){
        System.out.println("队列已满！无法添加");
        return false;
    }
    //添加元素到队列
    arr[rear] = data;
    //改变尾指针位置
    rear = (rear+1) % arrLen;
    //队列元素个数自增
    size++;
    return true;
}

入队测试

pop()方法

pop()方法出队，即删除队列头部元素，并返回。需要先判断一下队列是否为空，如果不会空，直接返回队列头的元素，之后移动队列头指针即可。

代码实现

/**
 * 删除队列中元素，从队列头部开始删除，先进先出
 * @return 删除的元素值
 */
public Object pop(){
    try{
        //判断队列是否为空
        if(!isEmpty()){
            //取出队列中的第一个元素
            Object data = arr[front];
            //移动头指针，队列头部
            front = (front+1) % arrLen;
            size--;
            return data;
        }
        return false;
    }catch (Exception e){
        return false;
    }
}

出队测试

peek()方法

peek()方法取出队列中第一个元素，和pop()出队方法差不多，需要先判断队列是否为空，如果不为空，直接返回队列头部元素即可。

代码实现

/**
 * 取出队列中第一个元素
 * @return 队列中第一个元素
 */
public Object peek(){
    try{
        if(!isEmpty()){
            return arr[front];
        }
        return false;
    }catch (Exception e){
        return false;
    }
}

clear()方法

clear()方法清空队列中的所有元素，清空队列中元素，只需要把队列头结点、尾结点和队列元素数量恢复初始化即可。

代码实现

public void clear(){
    front = rear = 0;
    size = 0;
}

全部代码

上述基于数组实现了队列的一些常用方法，下面是上述案例中的所有代码。有错误地方欢迎指出。

public class StrQueue {
    //队列数组
    public Object[] arr;
    //头指针
    public int front = 0;
    //尾指针
    public int rear = 0;
    //队列中元素个数
    public int size = 0;
    //队列数组长度默认为10
    public int arrLen = 10;

    //构造方法
    public StrQueue() {
        //无参构造方法，队列数组默认长度设置为10
        arr = new Object[arrLen];
    }

    //指定队列长度的构造方法
    public StrQueue(int arrLen) {
        this.arrLen = arrLen;
        arr = new Object[arrLen];
    }

    //判断队列是否满了
    public Boolean isFull(){
        //队列头和队列尾相等，即队列已满
        return (rear + 1) % arrLen == front;
    }

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

    //返回队列中的元素个数
    public Integer getSize(){
        return size;
    }

    /**
     * 添加元素到队列，队列添加元素都是添加在队列尾部
     * @param data 添加的元素值
     * @return Boolean
     */
    public Boolean add(Object data){
        //判断队列是否满了
        if(isFull()){
            System.out.println("队列已满！无法添加");
            return false;
        }
        //添加元素到队列
        arr[rear] = data;
        //改变尾指针位置
        rear = (rear+1) % arrLen;
        //队列元素个数自增
        size++;
        return true;
    }

    //遍历队列
    public void traverse(){
        //先找到队列头，从队列头部开始遍历
        int i = front;
        while (i != rear){
            System.out.println("编程小马：" + arr[i]);
            //移动队列头
            i = (i + 1) % arrLen;
        }
    }

    /**
     * 删除队列中元素，从队列头部开始删除，先进先出
     * @return 删除的元素值
     */
    public Object pop(){
        try{
            //判断队列是否为空
            if(!isEmpty()){
                //取出队列中的第一个元素
                Object data = arr[front];
                //移动头指针，队列头部
                front = (front+1) % arrLen;
                size--;
                return data;
            }
            return false;
        }catch (Exception e){
            return false;
        }
    }

    /**
     * 取出队列中第一个元素
     * @return 队列中第一个元素
     */
    public Object peek(){
        try{
            if(!isEmpty()){
                return arr[front];
            }
            return false;
        }catch (Exception e){
            return false;
        }
    }

    //清空队列
    public void clear(){
        front = rear = 0;
        size = 0;
    }

    public static void main(String[] args) {
        //实例一个队列
        StrQueue queue = new StrQueue();
        //添加元素
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        //遍历队列
        queue.traverse();
        System.out.println();

        System.out.println("出队的元素：" + queue.pop());
        queue.traverse();
    }
}