数据结构-队列的链表实现以及操作

队列的概述 

正如上次文章所述。队列的实现方式有很多种,其中一种就是使用最简单的数组来实现。还有使用链表的方式来实 现队列。这里简单回顾下:

 

队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行 插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队 头。队列中没有元素时,称为空队列。 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队,从 队列中删除一个队列元素称为出队。因 为队列只允许在一端插入,在另一端删除,所以只有最早进入队列的元素才 能最先从队列中删除,故队列又称为先 进先出(FIFO—first in first out)线性表。 

 

02数组和链表的存储数据的特点 

☑ 数组

 

在内存中,数组是一块连续的区域,申请的内存必须是连续的,而且数组申请的时候需要指定长度(也就是说需要 提前申请)。例如:申请了长度为10 ,但是如果里面只存储了5个元素。那么其他的内存就浪费了。

 

另外,数据的插入 和 删除 效率低下,因为数组是连续的,如果在插入的时候,就要求后续数据,在内存中往后移 动。例如(就像看电影座位有5个座位,中间有人坐了,如果来一个人坐中间,原本的人就要移动座位才行)扩展不容易,因为是提前申请内存空间,如果不够就没办法继续存储。如果申请太多,没用就是资源浪费了。

 

读取效率高,因为数组的地址是连续的,并且知道地址之后,很快就可以根据地址查询数据了。

 

☑ 链表

 

链表中申请的内存地址是随机的,可以不重复,也就意味着 可以充分利用资源,不会有像数组那样的连续内存。增加和删除数据 效率高,因为链表(包括单列表和双链表),有头结点和尾结点,从头部或者从尾部添加结点(数 据)的时候只需要记住原头不结点的地址或者是尾部结点的地址即可。很快便能申请内存地址。

 

扩展容易,因为不需要连续申请内存,数据可以存储在任意的内存地址中。

 

查询数据的时候效率低下,因为链表中的数据都是通过头来找到的,(要找链表中的一个数据,必须就是从头开始找起)。

 

03链表的队列实现 

实现思路:

·创建一个双链表类 

·创建一个以链表实现的队列类,比如实现Queue的队列接口 

·在队列类中使用链表作为数据存储 

·简单实现入队和出队的模拟 

 

☑  创建双链表类 

 

package com.itheima.link;

 

import java.util.Comparator;

import java.util.Iterator;

 

/**

 * 双链表

 *

 * @author

 *

 */

public class MyDoubleLink2 implements Iterable {

 

    /**

     * 节点的封装类

     *

     * @author Administrator

     *

     */

    private class Node {

        Node prev; // 上一个节点

        E data;// 数据

        Node next;// 下一个节点

    }

   

    private Node head;// 头节点

    private Node rear;// 尾节点

 

   /**

     * 删除数据: 1.只有一个数据 2.删除头节点 3.删除尾节点 4.删除中间节点

     *

     * @param data

     */

    public void remove(Object data) {

        // 1. 查找数据是否存在,查找数据所在的节点

        Node node = findData(data);

 

        // 2.判断node是否存在

        if (node != null) {

            remove(node);

        }

    }

   

    /**

     * 是否有数据

    * @return

     */

    public boolean isEmpty(){

        return head == null;

    }

   

    /**

     * 移除尾部的数据

     * @return

     */

    public E removeRear(){

        E data = null;

        if (rear != null) {

            data = rear.data;

            //移除

            rear = rear.prev;

            if (rear == null) {

                //没有节点

                head = null;

            } else {

                rear.next = null;

            }

        }

        return data;

    }

    /**

     * 移除头部的数据

     * @return

     */

    public E removeHead(){

        E data = null;

        if (head != null){

            data = head.data;

           //下一个数据成为头节点

            head = head.next;

            //后面没有

            if (head != null)

                head.prev = null;

            else {

                //没有数据

                rear = null;

            }

        }

        return data;

    }

    /**

     * 是否包含数据

     *

     * @param data

     * @return

     */

    public boolean contains(Object data) {

        return findData(data) != null;

    }

 

    /**

     * 删除节点

     *

     * @param node

     */

    private void remove(Node node) {

        if (node == head && node == rear) {

            // 1.只有一个数据

           head = null;

            rear = null;

        } else if (node == head) {

            // 2.删除头节点,后面肯定有节点

            head = head.next;

            head.prev = null;

 

        } else if (node == rear) {

            // 3.删除尾节点,前面肯定有节点

            rear = rear.prev;

            rear.next = null;

 

        } else {

            // 4.删除中间节点,前后肯定有节点

            node.prev.next = node.next;

            node.next.prev = node.prev;

        }

    }

 

    /**

     * 查找数据所在的节点

    *

     * @param data

     * @return

     */

    private Node findData(Object data) {

 

        Node node = head;

        while (node != null) {

            if (node.data.equals(data)

                    && node.data.hashCode() == data.hashCode()) {

                // 找到数据

                break;

            } else {

                // 继续下一个

                node = node.next;

            }

        }

        return node;

    }

    /**

     * 从头部添加数据

     *

     * @param data

     */

    public void addHead(E data) {

        // 1. 创建新的节点

        Node node = new Node();

        // 2. 把数据放入节点中

        node.data = data;

        // 3. 把节点链接到链表中

        // 从链表的尾部添加数据

        if (head == null) {

            // 说明链表是空的 ,node就成头节点

            rear = node;

            head = node;

        } else {

            // 有头节点

            head.prev = node;

            node.next = head;

            head = node;

        }

    }

 

    /**

     * 添加数据,从链表的尾部添加数据

     *

     * @param data

     */

    public void add(E data) {

        // 1. 创建新的节点

        Node node = new Node();

        // 2. 把数据放入节点中

        node.data = data;

        // 3. 把节点链接到链表中

        // 从链表的尾部添加数据

        if (rear == null) {

            // 说明链表是空的 ,node就成头节点

            rear = node;

            head = node;

        } else {

            // 有头节点

            rear.next = node;

            node.prev = rear;

            rear = node;

        }

    }

 

    @Override

    public String toString() {

        StringBuilder mess = new StringBuilder("[");

 

        // 遍历链表中所有的数据

        Node node = head;// 从头节点开始遍历数据

 

        while (node != null) {

            // 有数据

            // 拼接数据

            // 判断是否是尾节点

            if (node != rear) {

                mess.append(node.data + ", ");

            } else {

                mess.append(node.data);

            }

 

            // 条件的改变

            node = node.next;

        }

        mess.append("]");

 

        return mess.toString();

    }

 

    @Override

    public Iterator iterator() {

        class MyIte implements Iterator {

            private Node node = head;// 从头节点遍历

 

            @Override

            public boolean hasNext() {

                return node != null;

            }

 

            @Override

            public Object next() {

                // 获取数据

                Object data = node.data;

                // 设置下一个数据

                node = node.next;

                return data;

            }

 

            @Override

            public void remove() {

                // 删除next方法返回的数据

                MyDoubleLink2.this.remove(node.prev);

            }

 

        }

        return new MyIte();

    }

 

}

 

从尾部结点的数据方法如下:

 

public void add(E data) {

        // 1. 创建新的节点

        Node node = new Node();

        // 2. 把数据放入节点中

        node.data = data;

        // 3. 把节点链接到链表中

        // 从链表的尾部添加数据

        if (rear == null) {

            // 说明链表是空的 ,node就成头节点

            rear = node;

            head = node;

        } else {

            // 有头节点

            rear.next = node;

            node.prev = rear;

            rear = node;

        }

 }

☑ 创建以链表存储数据的队列类 

 

package com.itheima.queue;

 

import com.itheima.link.MyDoubleLink;

 

import java.util.Collection;

import java.util.Iterator;

import java.util.Queue;

 

/**

 * 描述

 *

 * @author 三国的包子

 * @version 1.0

 * @package com.itheima.queue *

 * @since 1.0

 */

public class MyLinkQueue implements Queue {

      

    private MyDoubleLink datas = new MyDoubleLink2<>();

 

    @Override

    public boolean add(E e) {

        datas.add(e);

        return true;

    }

 

   @Override

    public E poll() {

        return datas.removeHead();

    }

 

    @Override

    public String toString() {

        return datas.toString();

    }

 

    @Override

    public int size() {

        return 0;

    }

 

    @Override

    public boolean isEmpty() {

        return datas.isEmpty();

    }

 

    @Override

    public boolean contains(Object o) {

        return false;

    }

 

    @Override

    public Iterator iterator() {

        return null;

    }

 

    @Override

    public Object[] toArray() {

        return new Object[0];

    }

 

    @Override

    public T[] toArray(T[] a) {

        return null;

    }

 

    @Override

    public boolean remove(Object o) {

        return false;

    }

 

    @Override

    public boolean containsAll(Collection c) {

        return false;

    }

 

    @Override

    public boolean addAll(Collection c) {

        return false;

    }

 

    @Override

    public boolean removeAll(Collection c) {

        return false;

    }

 

    @Override

    public boolean retainAll(Collection c) {

        return false;

    }

 

    @Override

    public void clear() {

 

    }

 

    @Override

    public boolean offer(E e) {

        return false;

    }

 

    @Override

    public E remove() {

        return null;

    }

 

    @Override

    public E element() {

        return null;

    }

 

    @Override

    public E peek() {

        return null;

    }  

}

 

方法解析:

为了以后的扩展性 可以实现Queue的接口,此处为演示 只实现了其中的几个方法:

 

·add(E e)  添加数据(入队)

·poll()   移除数据(出队)

·isEmpty() 判断队列是否为空

·toString() 重写方法 便于打印

 

☑ 创建双链表的数据储存对象 

在队列类中创建

 private MyDoubleLink datas = new MyDoubleLink2<>();

 

☑ 入队方法 

入队方法如下,参考刚才的方法。入队的元素从尾部结点添加即可。

@Override 

public boolean add(E e) {    

datas.add(e);    

return true; 

}

如下图所示:

解释:

·将原尾结点的NEXT指向新的结点 

·将新结点的prev指向原尾结点

·将新结点作为尾结点(也就是将尾结点的引用指向那个新的结点)

理解图如下:

☑ 出队方法

 @Override    

public E poll() {        

return datas.removeHead();    

}

 

队列的方式是:先进先出,该方法表示从头开始删除节点。也就是出队。头先添加,最先出去的也是头结点。

 

如下图:

·先判断是否有头 如果有,那么将头结点引用指向下一个结点。

·再将头结点的prev赋值为空即可。

04总结

以上演示了队列的链表实现方式。

 

对于想快速访问,不经常进行插入和删除的操作 可以使用数组。对于经常进行添加和删除,对查询没有特别要求的可以使用链表。 ​​​​

你可能感兴趣的:(技术交流,传智播客西安中心)