• ArrayDeque API 与算法分析


    ArrayDeque 是双端队列的动态数组实现,可以当作栈和队列来使用。作为栈时,它的效率比 Stack 更高,作为队列时,效率比 LinkedList 更高。ArrayDeque 大部分操作的时间复杂度都是 O(1)。本文将介绍 ArrayDeque 的核心 API 以及其内部实现的算法。

    1. 数据结构

    ArrayDeque 的数据结构非常简单,包含一个用于存储数据的 Object 数组和两个分别指向队列头和尾的索引。

    transient Object[] elements; // non-private to simplify nested class access
    transient int head;
    transient int tail;
    

    2. 构造方法

    ArrayDeque 有 3 个构造方法。

    2.1 ArrayDeque()

    ArrayDeque() 方法很简单,仅仅是创建了一个长度为 16 的数组 elements。即 ArrayDeque 的容量为 16。

        public ArrayDeque() {
            elements = new Object[16];
        }
    

    2.2 ArrayDeque(int numElements)

    此方法传入一个整数 numElements,elements 数组的长度取决于参数 numElements,但 elemenets 的长度不是直接取 numElements,而是通过 calculateSize(int numElements) 计算之后的值。

    public ArrayDeque(int numElements) {
        allocateElements(numElements);
    }
    
    private void allocateElements(int numElements) {
        elements = new Object[calculateSize(numElements)];
    }
    

    calculateSize(int) 是一个静态工具方法,传入一个整数 numElements,返回一个恰好大于 numElements 且为 2 的整数次方的值。注意是大于,例如:输入 4,输出的为 8。这里的算法很巧妙,先通过 5 次位操作将 numElements 最高位左侧的二进制位全部置为 1,再加 1 得到返回值。

    事实上 elements 数组在 ArrayDeque 的整个生命周期中长度都为 2 的整数次方。

        private static int calculateSize(int numElements) {
            int initialCapacity = MIN_INITIAL_CAPACITY;
            // Find the best power of two to hold elements.
            // Tests "<=" because arrays aren't kept full.
            if (numElements >= initialCapacity) {
                initialCapacity = numElements; // 这里的位操作关注 numElements 的最高位即可
                initialCapacity |= (initialCapacity >>>  1);
                initialCapacity |= (initialCapacity >>>  2);
                initialCapacity |= (initialCapacity >>>  4);
                initialCapacity |= (initialCapacity >>>  8);
                initialCapacity |= (initialCapacity >>> 16); // 最高位左侧的二进制位已经全部为 1
                initialCapacity++; // 得到一个大于 numElements 且恰好为 2 的整数次幂的数
    
                if (initialCapacity < 0)   // 检查是否溢出
                    initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
            }
            return initialCapacity;
        }
    

    2.3 ArrayDeque(Collection<? extends E> c)

    此方法可以传入一个集合,集合中的元素会按照集合中元素的迭代顺序添加到 ArrayDeque 的尾部。调用的为 addLast(e) 方法。

        public ArrayDeque(Collection<? extends E> c) {
            allocateElements(c.size());
            addAll(c);
        }
    

    3. 核心 API

    ArrayDeque 的 API 是围绕如何在一个动态循环数组进行的一系列操作展开。动态体现在 ArrayDeque 的容量是可以动态扩展的,循环体现在 elements 数组在逻辑上首尾相连接的(物理上 elements 是一个数组,头是 0 ,尾是 elements.length-1)。一系列操作指的是双端队列的操作。

    下面通过绘制 ArrayDeque 内部存储结构的方式描述其核心 API 和算法。

    3.1 实例化

    ArrayDeque<Character> deque= new ArrayDeque();
    

    实例化时 head 和 tail 指针均指向了索引 0 位置。head 总是从右往左循环移动,tail 总是从左往右循环移动。头部添加的下一个元素总是存放在 head 下一个移向的索引位置,尾部添加的下一个元素总是存放在当前 tail 所在的位置。

    3.2 尾部添加 addLast(e)

    deque.addLast('A');
    

    addLast(e) 方法往双端队列的尾部添加元素,将元素放入 elements[tail],tail 往右移动一个位置。如果已经 tail 超出了索引范围,则指向 0 。循环利用数组。需要注意的是 ArrayDeque 不能存放 null 元素,不过 Deque 的另一实现 LinkedList 却可以。

    JDK 源码使用了高效的位操作实现了这个逻辑。

        public void addLast(E e) {
            if (e == null) // ArrayDeque 不能存放元素 null
                throw new NullPointerException();
            elements[tail] = e;
            // 因为 elements.length 总是 2 的整数次方,所以 elements.length - 1 所有二进制位均为 1,
            // 若 tail+1 < elements.length,则 (tail + 1) & (elements.length - 1) 结果即为 tail+1;
            // 若 tail+1 == elements.length,表示下标越界,则 (tail + 1) & (elements.length - 1) 值为 0
            // 这里可以解释为什么长度要设置为 2 的整数次方,目的是为了能够高效地进行位操作
            // 后面还判断了是否等于 head,相等则表示 elements 数组放满了,此时触发扩容
            if ( (tail = (tail + 1) & (elements.length - 1)) == head)
                doubleCapacity(); // this.elements 数组长度扩容为原来的两倍
        }
    

    3.3 头部添加 addFirst(e)

    deque.addFirst('B');
    

    与尾部添加类似,不过移动的是 head 指针,head 指针从往左循环移动 1 个位置,放入元素 elements[head](移动指针和放入元素的顺序与 addLast() 相反)。与 addLast(e) 类似,源码中同样使用了高效的位操作来进行移动,进行了扩容判断。

    3.4 获取头部元素 getFirst() / peekFirst() 和获取尾部元素 getLast() / peekLast()

    deque.getFirst(); // 返回 B
    deque.getLast(); // 返回 B
    deque.peekFirst(); // 返回 A
    deque.peekLast(); // 返回 A
    

    从前面尾部添加元素可知,双端队列中有元素的前提下,head 总是指向刚刚往双端队列头部添加的元素的位置,tail 总是指向存放下一个往双端队列添加元素的位置。因此,getFirst() / peekFirst() 返回的是 head 位置的元素,而 getLast() / peekLast() 返回的是上一次 tail 所在元素的位置。

    其中 getXXX() 会对获取的值进行判断,若为空,则抛出 NoSuchElementException。前面提到,ArrayDeque 不能存放 null 元素,因此值为空的另一层意思是这个 ArrayDeque 没有存放元素。而 peekXXX() 不会对返回的值进行判断,若获取到 null 则表示这个双端队列中没有元素。可以根据需求来选择相应的 API。

        public E getFirst() {
            @SuppressWarnings("unchecked")
            E result = (E) elements[head];
            if (result == null)
                throw new NoSuchElementException();
            return result;
        }
    
        /**
         * @throws NoSuchElementException {@inheritDoc}
         */
        public E getLast() {
            @SuppressWarnings("unchecked")
            E result = (E) elements[(tail - 1) & (elements.length - 1)];
            if (result == null)
                throw new NoSuchElementException();
            return result;
        }
    
        public E peekFirst() {
            // elements[head] is null if deque empty
            return (E) elements[head];
        }
    
        @SuppressWarnings("unchecked")
        public E peekLast() {
            return (E) elements[(tail - 1) & (elements.length - 1)];
        }
    

    双端队列中还有若干 API 与上面提到的 API 等价,例如:peek() 与 peekFirst()。更多说明可以参考这篇:Java 双端队列接口 Deque

    3.5 移除元素 removeFirst() / pollFirst() 和 removeLast() / pollLast()

    上面两组 API 中,removeFirst() 调用了 pollFirst(),removeLast() 调用了 pollLast(),只是增加了返回值为空时抛出异常的内容。

    与添加元素相反,移除元素时,pollFirst() 先获取当前元素,然后移动 head 指针往右循环移动 1 个位置;pollLast() 则是先向左循环移动 1 个位置,再获取元素。这里需要注意,head 指针和 tail 指针在 ArrayDeque 有元素的时候才移动,没有元素的时候不会移动。

        public E pollFirst() {
            int h = head;
            @SuppressWarnings("unchecked")
            E result = (E) elements[h];
            // Element is null if deque empty
            if (result == null) // 返回值 null,不移动 head
                return null;
            elements[h] = null;     // 这一句看起来是多余的,但它的目的是让数组 elements 不再引用移除的对象,这样 GC 就能够将对象回收了。
            head = (h + 1) & (elements.length - 1); // head 循环右移 1 个位置
            return result;
        }
    
    deque.pollLast(); // 返回 'A',tail 往左循环移动 1 个位置,head 不动
    

    deque.pollLast(); // 返回 'B',tail 往左循环移动 1 个位置,head 不动
    

    deque.pollFirst(); // 返回 null, tail 和 head 均不动
    

    3.6 扩容

    不断调用 addFirst(e) 和 addLast(e) 往里面增加元素,当元素增加到 elements 数组存放不下(即双端队列有元素的情况下 head == tail) 时,ArrayDeque 的容量会自动增加 1 倍。

    deque.addLast('A');
    deque.addLast('B');
    ...
    
    deque.addLast('M');
    

    elements 数组达到如下状态,此时还差 1 个元素就满了。

    再往里添加一个元素。

    deque.addFirst('L');
    

    调用 deque.add('L') 时,元素 'L' 先放入到数组中,tail 往右循环移动 1 个位置。然后进行判断,发现 tail 等于 head,触发扩容。扩容过程在 doubleCapacity() 方法中。

        private void doubleCapacity() {
            assert head == tail;
            int p = head;
            int n = elements.length;
            int r = n - p; // number of elements to the right of p
            int newCapacity = n << 1;
            if (newCapacity < 0) // 整数溢出了
                throw new IllegalStateException("Sorry, deque too big");
            Object[] a = new Object[newCapacity];
            System.arraycopy(elements, p, a, 0, r); // p=head 以及其右边部分先放到新数组左侧
            System.arraycopy(elements, 0, a, r, p); // p=head 左边部分尾随。
            elements = a;
            head = 0;
            tail = n;
        }
    

    4. 小结

    ArrayDeque 在不考虑扩容的情况下,ArrayDeque 头部和尾部操作都仅仅是移动一下索引,效率极高,时间复杂度为 O(1)。

    ArrayDeque 的实现中没有线程同步操作,因此 ArrayDeque 是非线程安全的,并发访问一个 ArrayDeque 可能导致错误。

    ArrayDeque 存储结构是一个 Object 数组,数组的长度总是 2 的整数次方,这是 ArrayDeque 某些代码能够进行位操作的基础。

  • 相关阅读:
    Golang调用windows下的dll动态库中的函数
    Golang 编译成 DLL 文件
    go 通过nginx代理后获取用户ip
    idea教程--Maven 骨架介绍
    idea教程--快速插入依赖
    Java开发名词解释
    Android Studio安装
    Java基础--Eclipse关联Java源码
    【排序基础】3、随机生成排序算法 测试用例
    【排序基础】2、使用模板(泛型)编写选择排序算法
  • 原文地址:https://www.cnblogs.com/robothy/p/14098883.html
Copyright © 2020-2023  润新知