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

àì夳堔傛蜴生んèń 2022-06-04 07:29 94阅读 0赞

上一篇文章了解了队列的概念和一些特性，并用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来解决线程安全的问题的。