看得见的数据结构Android版之队列篇

时间  2019-11-07 标签 看得见 数据 结构 android 队列

零、前言

1.现实世界里咱们更多讲究的是先来后到,先排队先买票，这样才有秩序，毕竟咱们没有计算机那么有耐心
2.使用队列结构能很好的模拟和解决相似生活中的事，好比消息的发送用队列维护就是很是恰当的
3.队列就像去动物园买票，先处理队列的头部，有新的人来了就后面排着去，慢慢等
4.还有一种颇有意思的队列是循环队列，它是因为数组对头部操做的困难性，从而转变一种思路，让数组也能很好的实现队列结构，后面会仔细分析一下
5.本例操做演示源码：但愿你能够和我在Github一同见证：DS4Android的诞生与成长，欢迎stargit

1.留图镇楼：队列的最终实现的操做效果:
数组实现普通队列：

蓝色区域是数组看见：初始化四个空间，不够再扩容，空闲太多再缩容github

数组实现普通队列.gif

链表实现普通队列：

队列综合操做.gif

2.队列结构的简介：
队列是一种线性的数据结构  
特性：尾部添加，头部取出 即先进先出FIFO  
操做：enqueue入队  dequeue出队  getFront查看队首元素
复制代码

队列.png

1、队列接口

兵马未动，粮草先行，有接口好办事。编程

/**
 * 做者：张风捷特烈
 * 时间：2018/8/17 0017:15:57
 * 邮箱：1981462002@qq.com
 * 说明：队列接口
 */
public interface IQueue<T> {
    /**
     * 入队
     * @param el 元素
     */
    void enqueue(T el);

    /**
     * 出队
     * @return 元素
     */
    T dequeue();

    /**
     * 获取队首元素
     * @return 队首元素
     */
    T getFront();

    /**
     * 获取队列元素个数
     * @return 元素个数
     */
    int getSize();

    /**
     * 是否为空
     * @return 是否为空
     */
    boolean isEmpty();
}
复制代码

2、普通队列的数组实现

普通队列的数组实现----性能很是差,后面用数组实现循环队列来优化
为何会不好，由于尾添加和头删除，总有一个会让全部的人挪一挪，后面会用数组实现循环队列来优化数组

/**
 * 做者：张风捷特烈
 * 时间：2018/8/17 0017:15:57
 * 邮箱：1981462002@qq.com
 * 说明：普通队列的数组实现----性能很是差,后面用数组实现循环队列来优化
 */
public class ArrayChartQueue<E> implements IQueue<E> {
    private ArrayChart<E> array;//成员变量

    public ArrayChartQueue(int capacity) {
        this.array = new ArrayChart<>(capacity);
    }

    public ArrayChartQueue() {
        this.array = new ArrayChart<>();
    }

    @Override
    public void enqueue(E el) {
        array.add(el);
    }

    @Override
    public E dequeue() {
        return array.remove(0);
    }

    @Override
    public E front() {
        return array.get(0);
    }

    @Override
    public int size() {
        return array.size();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }
}
复制代码
2.数组普通队列的插入演示：

因为是基于数组来实现，因此一切的操做也是基于数组
初始四个大小的数组，就像招待处预留四把椅子，而后等椅子坐满了，再来加椅子bash

数组普通队列的插入.gif

3.数组普通队列的查看首元演示：

数组普通队列查看首元.gif

4.数组普通队列的移除演示：

数组表结构移除头部...万恶之源，千万不要用，此处仅演示! 此处仅演示!此处仅演示!!
数组表结构移除头部...万恶之源，千万不要用，此处仅演示! 此处仅演示!此处仅演示!!微信

数组普通队列移除首元.gif

3、循环队列

基于数组实现的队列在队首取出时会使得整队移动，效率会很低
可是壮哉我大数组,岂会连个小小的队列都搞不定，之后还哪还有脸立足王座...因而循环队列出现了
提及循环你们脑子里都是一个圈来回转,循环小数表示不服... 只要有周期性就是循环，想成一个圈就狭隘了数据结构

1.循环队列实现的思路：
不就是想要知道队尾和队首是那个嘛，我标出来，维护一下给你不就好了吗  
注意：这里的优点在于维护了队尾和队首的标示，插入尾和删除头都是定点，并且数组总体不移动,而是标示在动
新加元素时，队尾表识后移，不够就扩容。删除头时队首标示  

循环队列特色：
为空时，`队尾标示==队首标示`,
队列满：`(队尾标示+1)%数组长度==队首标示`   
循环队列会使队首前一个位置不可用。
复制代码

循环队列.png

循环队列循环机制.png 

/**
 * 做者：张风捷特烈
 * 时间：2018/8/17 0017:16:03
 * 邮箱：1981462002@qq.com
 * 说明：数组实现循环队列
 */
public class ArrayLoopQueue<T> implements IQueue<T> {
    private T[] data;// 队列数据
    private int head;//队首标示
    private int tail;//队尾标示
    private int size;//元素个数
    public ArrayLoopQueue() {//无参构造：默认8个容量
        this(8);
    }
    public ArrayLoopQueue(int capacity) {
        // 由于会有一个浪费,因此+1
        data = (T[]) new Object[capacity + 1];
        head = 0;
        tail = 0;
        size = 0;
    }
    @Override
    public void enqueue(T el) {
        if (isFull()) {//加入时满了---扩容
            grow(capacity() * 2);
        }
        data[tail] = el;//在队尾插入
        //插入数据时对尾标示进行维护-----
        tail = (tail + 1) % data.length;
        size++;
    }
    @Override
    public T dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("MakeSure it's not an empty } T ret = data[head]; data[head] = null;//让队首移除 //队首移除时对首标示进行维护----- head = (head + 1) % data.length; size--; //闲置太多---缩容 if (size == capacity() / 4 && capacity() / 2 != 0 && size > 4) { grow(capacity() / 2); } return ret; } @Override public T front() { if (isEmpty()) { throw new IllegalArgumentException("MakeSure it's not an empty } return data[head]; } /** * 扩容/缩容 * * @param newCapacity 新的容量 */ private void grow(int newCapacity) { T[] newData = (T[]) new Object[newCapacity + 1]; for (int i = 0; i < size; i++) { // 此时在newData中队首对齐回来，data中就得有一个front的偏移量 newData[i] = data[(i + head) % data.length]; } data = newData; head = 0; tail = size; } /** * 获取容量 * * @return 容量 */ public int capacity() { return data.length - 1; } /** * 队列元素个数 * * @return 元素个数 */ @Override public int size() { return size; } /** * 是否为空 * * @return 是否为空 */ @Override public boolean isEmpty() { return head == tail; } /** * 队列是否满了 * * @return 队列是否满了 */ private boolean isFull() { // tail的下一个位置等于head时 return (tail + 1) % data.length == head; } } 复制代码

4、单链表式实现队列结构

链表和队列可谓自然配，链表的头删除，头获取很快,但尾添加要获取尾部，须要遍历一次，很差
但能够维护首位标识，使队尾也容易获取。(固然你也能够用双链表...直接批件衣服，改都不用改)
注释的很清楚了，看着代码顺一下，或debug走一波，我就不赘述了ide

/**
 * 做者：张风捷特烈
 * 时间：2018/8/17 0017:22:50
 * 邮箱：1981462002@qq.com
 * 说明：单链表实现队列
 */
public class SingleLinkedQueue<T> implements IQueue<T> {

    private Node head;//头节点
    private Node tail;//尾节点

    private int size;//元素个数

    public SingleLinkedQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void enqueue(T el) {//入队
        // 若是队尾为空，说明队列是空的。由于tail一直指向最后一个非空节点。
        if (tail == null) {
            tail = new Node(null, el);//初始化
            head = tail;
        } else {
            tail.next = new Node(null, el); // 新来的排到后面去
            tail = tail.next; //更新队尾
        }
        size++;
    }

    @Override
    public T dequeue() {//出队
        if (isEmpty())
            throw new IllegalArgumentException("MakeSure it's not an empty queue");
        Node targetNode = head;//我是老大
        head = head.next; // 我是老二，但我要篡位了...之后哥就是老大
        targetNode.next = null; //前任老大走了....
        if (head == null) {// 若是头结点为空
            tail = null;
        }
        size--;
        return targetNode.el;
    }

    @Override
    public T front() {
        if (isEmpty())
            throw new IllegalArgumentException("MakeSure it's not an empty queue");
        return head.el;
    }

    @Override
    public int size() {
        return size;
    }

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

    private class Node {
        private T el;//改节点上的元素
        private Node next; //下一节点
        /**
         * 两参构造
         *
         * @param next //下一节点
         * @param el   生成节点的元素值
         */
        private Node(Node next, T el) {
            this.el = el;
            this.next = next;
        }
    }
}
复制代码

5、小结

1.数组普通队列：ArrayChartQueue测试
方法\数量 1000 次10000次 10W次 100W次 1000次
enqueue 0.0006秒 0.0022秒 0.01571秒 0.06668秒 1.1375秒
dequeue 0.0111秒 0.2707秒 18.7684秒 ---- --
2.数组环形队列：ArrayLoopQueue测试
方法\数量 1000 次10000次 10W次 100W次 1000次
enqueue 0.0004秒 0.0019秒 0.01775秒 0.05414秒 0.6896秒
dequeu 0.0005秒 0.0021秒 0.0091秒 0.0360秒 0.3327秒
3.链表队列：SingleLinkedStack测试
方法\数量 1000 次10000次 10W次 100W次 1000次
enqueue 0.0011秒 0.0031秒 0.0099秒 0.4881秒 3.1186秒
dequeue 0.0002秒 0.0013秒 0.0046秒 0.0221秒 0.1388秒

可见循环队列仍是蛮好的，壮哉，我大数组!
数组普通队列,就认识一下吧...不要用它。
数组环形队列和链表队列的比较也就至关于数组和链表的比较oop

本系列后续更新连接合集：(动态更新)

后记：捷文规范

2.本文成长记录及勘误表
项目源码 日期 备注
V0.1--github 2018-11-24 看得见的数据结构Android版之队列结构的实现
3.更多关于我
笔名 QQ 微信 爱好
张风捷特烈 1981462002 zdl1994328 语言
个人github 个人简书 个人掘金 我的网站
4.声明

1----本文由张风捷特烈原创,转载请注明
2----欢迎广大编程爱好者共同交流
3----我的能力有限，若有不正之处欢迎你们批评指证，一定虚心改正
4----看到这里，我在此感谢你的喜欢与支持post

icon_wx_200.png
联系我们 沪ICP备13005482号-10