基础数据结构——双端队列

概述

 链表实现

我们基于双向环形链表去实现双端队列

为什么要基于双向环形链表去实现环形数组

双向：

如果是单项链表，我们在删除末尾指针指向的元素（即为尾指针-1）时需要一一去查找，而双向链表直接通过prev操作即可

环形;

只需要设置一个哨兵节点使其即充当头又充当尾，节省了一个节点

方法构造

public class LinkedListDeque<E> implements Deque<E>,Iterable<E>{



    static class Node<E>{
        Node<E> next;
        E value;
        Node<E> prev;

        public Node( Node<E> next,E value, Node<E> prev){
            this.value = value;
            this.next = next;
            this.prev = prev;
        }
    }
    int size;
    int capaticy;
    Node<E> sentinel=new Node<E>(null,null,null);

    public LinkedListDeque(int capaticy) {
        this.capaticy = capaticy;
        sentinel.next=sentinel;
        sentinel.prev=sentinel;
    }

因为是双端环形链表，所以我们只需要设置一个哨兵节点，它的指向和前指向都是它自己

方法实现

//a added b
    @Override
    public boolean offerFirst(E e) {
        if (isFull()){
            return false;
        }
        Node<E> a=sentinel;
        Node<E> b=sentinel.next;
        Node<E> added=new Node<E>(a,e,b);
        a.next=added;
        b.prev=added;
        size++;
        return true;
    }
    //a added b末尾哨兵
    @Override
    public boolean offerLast(E e) {
        if (isFull()){
            return false;
        }
        Node<E> b=sentinel;
        Node<E> a=sentinel.prev;
        Node<E> added=new Node<E>(a,e,b);
        b.prev=added;
        a.next=added;
        size++;
        return true;
    }
    //a removed b
    @Override
    public E pollFirst() {
        if (isEmpty()){
            return null;
        }
        Node<E> a=sentinel;
        Node<E> removed=sentinel.next;
        Node<E> b=removed.next;
        a.next=b;
        b.prev=a;
        size--;
        return removed.value;
    }

    @Override
    public E pollLast() {
        if (isEmpty()){
            return null;
        }
        Node<E> b=sentinel;
        Node<E> removed=sentinel.prev;
        Node<E> a=removed.prev;
        b.prev=a;
        a.next=b;
        size--;
        return removed.value;
    }

    @Override
    public E peekFirst() {
        if (isEmpty()){
            return null;
        }
        return sentinel.next.value;
    }

    @Override
    public E peekLast() {
        if (isEmpty()){
            return null;
        }
        return sentinel.prev.value;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean isFull() {
        return size==capaticy;
    }
}

方法不难理解 本质上就是指针指向的变换

迭代器实现

@Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> p=sentinel.next;

            @Override
            public boolean hasNext() {
                return p!=sentinel;
            }

            @Override
            public E next() {
                E value=p.value;
                p=p.next;
                return value;
            }
        };
    }

只要p指针迭代递增不为哨兵节点，那么就返回当前指针的值

循环数组实现（基于head tail指针实现）

方法的原理分析

本质上这个方法还是需要牺牲一个数组的容量 

注意：在head tail+-的时候需要根据数组的下标进行转换，不然会超出范围 

我们来实现一下头尾指针操作的更新方法

索引值更新操作

static int inc(int i,int length){
        if (i+1>=length){
            return 0;
        }
        return i+1;
    }

    static int dec(int i,int length){
        if (i-1>=0){
            return i-1;
        }
        return length-1;
    }

方法实现

isFull方法

 当tail>head的时候，我们直接判断tail-head的值和数组长度-1是否相等

当head>tail的时候，我们判断head-tail==1就行

我们来看具体的方法

@Override
    public boolean isFull() {
        if(tail>head){
            return tail-head==array.length-1;
        }else if(head>tail){
            return head-tail==1;
        }else {
            return false;
        }
    }

其他方法

//head先--再存值
    @Override
    public boolean offerFirst(E e) {
        if(isFull()){
            return false;
        }
        head=dec(head,array.length);
        array[head]=e;
        return true;
    }

    //tail先存值再++
    @Override
    public boolean offerLast(E e) {
        if(isFull()){
            return false;
        }
        array[tail]=e;
        tail=inc(tail,array.length);
        return true;
    }

    //先取值，再++
    @Override
    public E pollFirst() {
        if(isEmpty()){
            return null;
        }
        E e=array[head];
        head=inc(head,array.length);
        return e;
    }

    //先--再取值
    @Override
    public E pollLast() {
        if(isEmpty()){
            return null;
        }
        tail=dec(tail,array.length);
        E e=array[tail];
        return e;
    }

    @Override
    public E peekFirst() {
        if(isEmpty()){
            return null;
        }
        return array[head];
    }

    @Override
    public E peekLast() {
        if(isEmpty()){
            return null;
        }
        return array[dec(tail,array.length)];
    }

我们根据方法原理去实现对应的方法

注意在peekLast方法中

return array[dec(tail,array.length)];

因为要考虑tail-1<0的情况，我们需要对索引值进行处理。

同时我们也要考虑内存释放问题

内存释放

在对数组操作时，如果我们没有使用引用，直接更下标去尽显操作，不需要进行释放操作，因为不管是把某一个位置的值改成0还是不变，占用的都是四个字节

在引用的操作的时候，需要进行相应的操作，将引用的设置为null

 如下

//先取值，再++
    @Override
    public E pollFirst() {
        if(isEmpty()){
            return null;
        }
        E e=array[head];
        array[head]=null;
        head=inc(head,array.length);
        return e;
    }

    //先--再取值
    @Override
    public E pollLast() {
        if(isEmpty()){
            return null;
        }
        tail=dec(tail,array.length);
        E e=array[tail];
        array[tail]=null;
        return e;
    }

迭代器实现

 @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                E e=array[p];
                p=inc(p,array.length);
                return e;
            }
        };
    }