学会一种数据结构二：队列的数组实现和链表实现

上一篇文章了解了队列的概念和一些特性，并用java简单实现一个队列。今天就实现队列两种最常见的实现
数组实现和链表实现。

队列的数组实现

代码：

public class CustomArrayQueue<E> {


    private int tail; //尾元素的位置

    private int head; //头元素的位置

    private float factory = 0.75F; //数组的扩容因子

    private Object[] table;//用于存放数据的数组

    private int default_lenght = 10; //数组的初始长度

    private int length; //当前数组的长度

    private int size = 0; //当前的数据量

    public CustomArrayQueue() { // 队列初始化，数组默认长度为10
        this.table = new Object[default_lenght];
        this.head = 0;
        this.tail = 0;
    }

    // 队列初始化，数组默认长度为传入的值，当<=0时，采用默认长度
    public CustomArrayQueue(int capacity) {

        this.head = 0;
        this.tail = 0;
        if (capacity <= 0) {
            this.table = new Object[default_lenght];
        } else {
            this.table = new Object[capacity];
        }
    }


    /**
     * 新增一个元素
     * 判断当前容量是否达到扩音的条件，如果达到扩容的条件，就在原来的长度上增加10个位置
     * 否则不扩容
     * 把新增的元素放到为元素的后一位
     * @param e
     * @return
     */
    public Object add(E e) {

        int tempLenght = table.length;
        BigDecimal tempBig = new BigDecimal(tempLenght);
        BigDecimal tailBig = new BigDecimal(tail);
        float tempFactory = tailBig.divide(tempBig, 2, BigDecimal.ROUND_UP).floatValue();
        if (tempFactory >= factory) {
            table = Arrays.copyOf(table, tempLenght + 10);
        }

        table[tail] = e;
        tail++;
        size++;
        return e;
    }

    //获取队列元素的数量
    public int size() {
        return size;
    }

    // 获取队列的长度
    public int length() {

        return table.length;
    }

    public E pop() {
        E e;
        if (size == 0) {
            return null;
        } else {
            e = (E)table[head];
            head++;
            size--;
            return e;
        }
    }
}

上面简单实现一个基于数组的队列，实现了几个简单的方法。

测试代码：

public class QueueTest {


    public static void main (String[] args) {
        //CustomQueue<String> queue = new CustomQueue<String>();
        CustomArrayQueue<String> queue = new CustomArrayQueue<>();
        queue.add("123");
        queue.add("456");
        queue.add("789");
        queue.add("147");

        System.out.println("数量=" + queue.size());
        System.out.println("取出第一个" + queue.pop());
        System.out.println("取出第二个" + queue.pop());
        System.out.println("取出第三个" + queue.pop());
        System.out.println("取出第四个" + queue.pop());
        System.out.println("取出第五个" + queue.pop());
        System.out.println("取出第六个" + queue.pop());
    }

}

输出结果：

数量=4
取出第一个123
取出第二个456
取出第三个789
取出第四个147
取出第五个null
取出第六个null

数组的实现的逻辑非常的简单，第一，数组是有序的，第二，数组的下标处理起来非常的简单。

但是这里是有问题，主要问题是：
1、容易产生冗余数据；
2、边界问题；

第一个冗余数据的问题，如下例子：
数组的容量为100，已经取出了98个元素，当前head为98,0-97位的数据已经被取走，这些位置已经空了，但是数组还在使用，如果新加元素只能继续扩容，继续往后面加，导致大量的位置空闲。
这种现象被称为“假上溢”现象；
这是使用数组实现必须解决的问题；；

第二个边界问题，如下例子：
当前内容只能分配100个元素的空间，无法扩容了，继续添加元素，这时没办法添加了。

这种现象被称为“真上溢”现象。

“真上溢”暂时没办法解决，但是“假上溢”现象是可以解决的；
下面是在自己实现的队列中解决“假上溢”问题。

解决“假上溢”有两种解决方法：
– 利用数组扩容方法；空余位置达到临界点时，就利用数组扩容方法新建一个数组，把原来的数据复制到新数据的0位。
– 采用循环队列的方式存储数据

数组扩容解决方案

代码：

  /**
     * 新增一个元素
     * 判断当前容量是否达到扩音的条件，如果达到扩容的条件，就在原来的长度上增加10个位置
     * 否则不扩容
     * 把新增的元素放到为元素的后一位
     * 当空余余位置大于10时，触发解决假上溢代码
     * @param e
     * @return
     */
    public Object add(E e) {

        int tempLenght = table.length;
        BigDecimal tempBig = new BigDecimal(tempLenght);
        BigDecimal tailBig = new BigDecimal(tail);
        float tempFactory = tailBig.divide(tempBig, 2, BigDecimal.ROUND_UP).floatValue();
        if (tempFactory >= factory) {
            table = Arrays.copyOf(table, tempLenght + 10);
        }

        table[tail] = e;
        tail++;
        size++;
        //当空余位置大于10时，触发解决假上溢代码
        if (head >= 10) {
            table = Arrays.copyOf(table, table.length + 10);
            head = 0;
            tail = tail - head;
        }

        return e;
    }

循环队列解决方案

代码：

/**
     * 新增一个元素
     * 判断当前容量是否达到扩音的条件，如果达到扩容的条件，就在原来的长度上增加10个位置
     * 否则不扩容
     * 把新增的元素放到为元素的后一位
     * 采用循环队列解决假上溢问题
     * @param e
     * @return
     */
    public Object add(E e) {

        int tempLenght = table.length;
        BigDecimal tempBig = new BigDecimal(tempLenght);
        BigDecimal tailBig = new BigDecimal(tail);
        float tempFactory = tailBig.divide(tempBig, 2, BigDecimal.ROUND_UP).floatValue();
        if (tempFactory >= factory) {
            table = Arrays.copyOf(table, tempLenght + 10);
        }

        int realIndex = tail/table.length;

        if (realIndex == head && tail > head) {
            //这是已经没有位置存放了，触发了真上溢问题，完整实现时，此时应该抛出异常
        }

        table[realIndex] = e;
        tail++;
        size++;
        当空余位置大于10时，触发解决假上溢代码
        //if (head >= 10) {
        //    table = Arrays.copyOf(table, table.length + 10);
        //    head = 0;
        //    tail = tail - head;
        //}

        return e;
    }

总结

以上就是队列的基本实现，主要是要理解先入先出的特性，还要明白这种实现的溢出问题。

队列的链表实现

在上一篇学习队列特性中写的一个简单实现，就是基于链表的队列实现，这里就不重复描述了，主要是需要对链表有一定的了解。
另外，这种实现发方式不存在“假上溢”的现象。

总结

上面描述队列的数组实现和链表实现，都是简单的实现，没有实现完成的代码，如果一个完整的实现，应该把通用方法提出来作为接口使用，数组实现和链表实现实现这个接口。

另外，文中并没有涉及队列遍历的问题，要实现一个可用的队列，必须实现遍历，一般情况下是实现匿名的Iterator子类。

还有并发安全的问题，并发安全有两种实现方法
– 用synchronized修饰所有操作数据的方法
– 用lock安全操作所有的数据

java源码中采用的就是ReentrantLock来解决线程安全的问题的。