java数据结构--队列

一.队列概念

队列是一种先进先出的数据结构，类似我们排队，头节点出，尾节点进

二.定义Queue接口

public interface Queue<E> {



    /**
     * 向队列尾添加元素
     * @return 添加成功返回true，添加失败返回false
     */
     boolean add(E e);

    /**
     * 从队列头删除一个节点，并取出该元素
     * @return 队头元素
     */
    E pull();

    /**
     * 从队列头取出该元素，但是不删除该节点
     * @return 队头元素
     */
    E peek();

    /**
     * 判断队列是否为空
     * @return 空为true，非空为false
     */
    boolean isEmpty();

    /**
     * 判断队列是否为满
     * @return 满为true，不满为false
     */
    boolean isFull();

}

三.单向带哨兵循环链表实现队列

/**
 * 单向哨兵循环链表实现队列
 * @author JJH
 * @param <E>
 */
public class LinkedListQueue<E> implements Queue<E> ,Iterable<E> {
    /**
     * 节点类
     */
    private  static class Node<E>{
       private E value;   //节点值
       private Node<E> next;  //下一个节点


        public Node(E value, Node<E> next) {
            this.value = value;
            this.next = next;
        }
    }

    //属性
    //头节点
    private Node<E> head = new Node<>(null,null);
    //尾节点
    private Node<E> tail = head;
    //当前的节点数
    private int size;
    //总的容量
    private int capcity = Integer.MAX_VALUE;

    {
        //可以把共有的方法写在构造代码块里
        //尾节点的下一个是头节点
        tail.next = head;
    }

    public LinkedListQueue(int capcity){
        this.capcity = capcity;
    }

    public LinkedListQueue() {
    }

    @Override
    public boolean add(E e) {
        /**
         * 向队尾添加一个元素需要改变三个指针：
         * 1.首先新建一个节点，
         * 2.将尾节点（尾指针）的next指向 新节点
         * 3.将尾指针(tail) 指向 新节点
         * 4.新节点 的 next指向头节点
         */
        Node<E> newNode = new Node<>(e,head);
        tail.next = newNode;
        tail = newNode;
        size++;  //当前长度加一
        return true;
    }

    @Override
    public E pull() {
        //先判断是否为空
        if (isEmpty()) {
            return null;
        }
        Node<E> first = head.next;
        E value = first.value;
        //特殊情况，如果只有一个节点，那么应该让尾指针指向head
        if(first == tail){
            tail.next = head;
        }
        head.next = first.next;
        size--;   //当前长度减一
        return value;
    }

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

    @Override
    public boolean isEmpty() {
        //当尾指针和头指针相等时候就是空的，否则不是空
        return tail == head;
    }

    @Override
    public boolean isFull() {
        //当当前长度等于总长度时为满
        return  size == capcity;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            //刚开始p指向哨兵的下一个节点，因为哨兵节点只是用来标记，不起存储作用
            Node<E> p = head.next;
            @Override
            public boolean hasNext() {
                //当p到指向头节点的时候表示循环完了，就停止
                return p != head;
            }

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

}

四.环形数组实现队列

/**
 * 环形数组实现队列
 * @author JJH
 */
public class ArrayQueue<E> implements Queue<E> ,Iterable<E>{

    private final Object[] array;

    private int head;
    private int tail;

    public ArrayQueue(int capacity){
        //为了给判断满的尾指针空出最后一个位置，我们把容量加一
        array = new Object[capacity+1];

    }
    
    @Override
    public boolean add(E e) {
       //先判断是否为满
        if(isFull()){
            return false;
        }
        array[tail] = e;
        //尾指针向后移动一个位置
        tail = (tail+1) % array.length;
        return true;
    }

    @Override
    public E pull() {
       if(isEmpty()){
           return null;
       }
       E value = (E) array[head];
       //头指针向后移动一个位置
       head = (head+1) % array.length;
       return value;
    }

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

    @Override
    public boolean isEmpty() {
        //当头指针和位置一样时为空
        return head == tail;
    }

    @Override
    public boolean isFull() {
        //当尾指针的下一个是头指针时，为满
        //为了能够循环，所有要对数组长度取模
        return (head+1) % array.length == head;
    }

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

            @Override
            public E next() {
               E value = (E) array[p];
               p = (p+1) % array.length;
               return value;
            }
        };
    }
}

 五.带当前size的环形数组

我们在环形数组中添加一个size，用来表示当前元素的个数，这样可以根据简便的判断空，满等

public class ArrayQueue2<E> implements Queue<E>,Iterable<E>{

    private final Object[] array;

    private int head;
    private int tail;
    private int size; //当前的元素个数

    public ArrayQueue2(int capacity){
        //因为添加了size,所以不用加一
        array = new Object[capacity];

    }

    @Override
    public boolean add(E e) {
        //先判断是否为满
        if(isFull()){
            return false;
        }
        array[tail] = e;
        //尾指针向后移动一个位置
        tail = (tail+1) % array.length;
        //当前元素个数加一
        size++;
        return true;
    }

    @Override
    public E pull() {
        if(isEmpty()){
            return null;
        }
        E value = (E) array[head];
        //头指针向后移动一个位置
        head = (head+1) % array.length;
        //当前元素个数减一
        size--;
        return value;
    }

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

    @Override
    public boolean isEmpty() {
        //当size为0时为空
        return size == 0;
    }

    @Override
    public boolean isFull() {
        //当size等于数组长度时为满
        return size == array.length;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            int count = 0;
            @Override
            public boolean hasNext() {
                return count < size;
            }

            @Override
            public E next() {
                E value = (E) array[p];
                p = (p+1) % array.length;
                count++;
                return value;
            }
        };
    }
}