日常学习随笔-自定义了一个双链表（注释蛮详细的）

一、双链表结构

　　最近总会抽出一些零碎的时间片段，尝试按照自己的想法自定一了一个双链表结构的集合。我发现，数组、单链表或者双链表，乃至其他结构，本质上就是一种思想，只要遵循结构的核心思想，实现方法会有很多种。数组和单链表就不多说了，前几篇也尝试自定义了，就双链表来说，就可以定义如下几种结构：

（1）头结点+...数据结点.....+尾结点

（2）头结点+...数据结点.....

（3）头结点+...数据结点.....头结点

（4）头结点+...数据结点.....+尾结点....头结点

（5）其他结构

本篇使用的是第（1）中结构，结构千千万，效率差异也很大，只要明白双链表的含义：

（从网上找到了几张图，也算很清晰，如下）

双链表结构：结构（3）

如何删除一个结点

如何新增一个结点

接下来，我就直接贴出双链表-结构（1）的源码了哈！

二、双链表：MyDoubleLinkedDefin源码

双链表类：MyDoubleLinkedDefin.java

package com.xfwl.algorithmAnalysis.linklsit;
/**
 * 数据结构学习-双链表
 * @function  自定义一个双链表
 * @author 小风微凉
 * @time  2018-5-14 下午1:11:11
 */
public class MyDoubleLinkedDefin<T> {    
    /**
     * 当前双链表的头结点
     */
    private Node head;    
    /**
     * 当前双链表的尾部结点
     */
    private Node bottom;
    /**
     * 当前链表的数据变化计数
     */
    private int modCount;
    /**
     * 当前链表中的结点个数(排除首尾这2个结点)
     */
    private int nodeCount;
    /**
     * 内置一个满足双链表的结点类
     */
    private class Node<T>{
        /**
         * 当前结点存放的数据域
         */
        public T data;
        /**
         * 当前结点的前驱结点的引用域
         */
        public Node<T> prev;
        /**
         * 当前结点的后驱结点的引用域
         */
        public Node<T> next;
        /**
         * 结点构造器
         */
        @SuppressWarnings("unchecked")
        public Node(T data,Node prev,Node next){
            this.data=data;
            this.prev=prev;
            this.next=next;
        }
    }
    /**
     * 构造器
     */
    @SuppressWarnings("unchecked")
    public MyDoubleLinkedDefin(){
        //初始化计数
        modCount=0;
        nodeCount=0;
        //初始化头结点和尾结点
        head=new Node<T>(null,null,null);
        bottom=new Node<T>(null,null,null);
        //清空双链表的数据:重置头尾结点的关联关系
        this.reset();
        System.out.println("头结点："+head);
        System.out.println("尾结点："+bottom);
    }
    /**
     * 重置双链表，重置头结点,尾结点
     */
    @SuppressWarnings("unchecked")
    private void reset(){
        //重置头结点
        this.head.data=null;
        this.head.prev=null;
        this.head.next=bottom;
        //重置尾结点
        this.bottom.data=null;
        this.bottom.next=null;
        this.bottom.prev=head;
    }
    /**
     * 向双链表中添加一个新的结点（追加到尾部）
     * @param data
     */
    public void add(T data){
        //判断当前数据的合法性
        if(data==null){
            throw new IllegalArgumentException("添加的参数不合法！");
        }
        //添加规则：添加当前结点到尾部结点的前驱结点
        Node curNode=new Node(data,this.bottom.prev,this.bottom);
        curNode.prev.next=curNode;
        this.bottom.prev=curNode;
        //计数++
        modCount++;
        nodeCount++;
        System.out.println("新加结点的前驱结点:"+curNode.prev);
        System.out.println("新加结点的后驱结点:"+curNode.next);
    }
    /**
     * 向双链表中的指定索引位置添加一个新的结点
     * @param index    位置索引值
     * @param data    结点数据域存储的值
     * 分析说明：
     *       链表和数组的结构明显存在差异，数组很容易根据索引下标的值找到指定位置的元素，但是链表却不可以，
     * 结构使然，所以只能从头结点，或者尾部结点开始向下或向上找到指定位置的元素。
     *      这里我提出一个想法，能不能在双链表中再维护一个数组，这个数组用于查找指定位置的元素，而链表结构用于
     * 新增，删除，修改元素！不过这也存在一个很明显的弊端，那就是，为了保证数组和链表结构中得数据统一性，这有
     * 增加了复杂度，降低了程序的运行效率。显然有点不合理！
     */
    public void add(int index,T data){
        //检测位置索引的合法性：也可抽成公共一个方法
        if(index<0 || index>= this.nodeCount){
            throw new IllegalArgumentException("位置索引值不在合理范围内！");
        }
        //创建一个新结点
        Node newNode=new Node(data,null,null);
        //找到要插入位置的结点
        Node tmpNode=this.findNode(index);
        //开始移动
        try{
            tmpNode.prev.next=newNode;
            newNode.prev=newNode;
            newNode.next=tmpNode;
            tmpNode.prev=newNode;
        }catch(Exception e){
            e.printStackTrace();
            throw e;
        }finally{
            //计数++
            modCount++;
            nodeCount++;
        }
    }
    /**
     * 从双链表中移除指定索引位置的结点
     * @param index 索引位置
     */
    public void remove(int index){
        //检测位置索引的合法性：也可抽成公共一个方法
        if(index<0 || index>= this.nodeCount){
            throw new IllegalArgumentException("位置索引值不在合理范围内！");
        }
        //找到指定位置的结点
        Node<T> tmpNode=this.findNode(index);
        //处理结点
        tmpNode.prev.next=tmpNode.next;
        tmpNode.next.prev=tmpNode.prev;
        //计数++
        modCount--;
        nodeCount--;
    }
    /**
     * 获取当前链表的尺寸大小
     * @return
     */
    public int size(){
        return this.nodeCount;
    }
    /**
     * 打印双链表
     */
    public void print(){
        if(this.nodeCount==0){
            System.out.println("当前双链表没有任何数据！");            
        }else{
            Node tmpNode=head;
            int count=0;
            System.out.println("**************开始打印***************************");
            while(tmpNode.next!=null){
                tmpNode=tmpNode.next;
                if(count==this.nodeCount){//过滤尾结点
                    break;
                }
                System.out.println("索引值："+count+"，结点数据："+tmpNode.data);                
                count++;
            }
            System.out.println("***************打印结束**************************");            
        }
    }
    /**
     * 找到双链表中指定位置的结点（先折半后再查找）
     * @param index    指定的位置索引值
     * @return    返回位置上的结点
     */
    public Node<T> findNode(int index){
        //检测位置索引的合法性
        if(index<0 || index>= this.nodeCount){
            throw new IllegalArgumentException("位置索引值不在合理范围内！");
        }
        //取链表一半的数量(计算的是索引值范围)
        int midCount=(this.nodeCount)/2;
        //计数起点
        int count=0;
        //拿到第一个结点数据
        Node tmp=head.next;
        //如果在前一半范围:[0,midCount]
        if(index>=0 && index<=midCount){            
             while(index!=count){//要找的位置!=计数位置   一直累计叠加到相等位置
                 tmp=tmp.next;
                 count++;
             }             
        }else if(index>midCount && index<this.nodeCount){//如果在后一半范围内:[midCount,this.nodeCount)
            //计数起点调高
            count=this.nodeCount-1;
            //从尾结点向前推
            tmp=bottom.prev;
            while(index!=count){//要找的位置!=计数位置   一直累计叠加到相等位置
                tmp=tmp.prev;
                count--;
            }    
        }
        return tmp;        
    }
    /**
     * 找到双链表中的指定结点所在的位置
     * @param node    要检索的结点对象
     * @return    返回位置索引值
     * 优化意见:
     *         这里的实现方法很中规中矩，可以优先判断当前检索的结点是否是头尾结点，过滤常用的检索情况。
     */
    public int findNodeIndex(Node node){
        int index=0;
        //拿到头结点
        Node tmp=head;
        while(tmp.next!=null){
            tmp=tmp.next;            
            index++;
        }
        return index;        
    }
}

测试运行类:Test2.java

package com.xfwl.algorithmAnalysis.linklsit;
/**
 * 双链表学习测试：
 * @function  
 * @author 小风微凉
 * @time  2018-5-17 下午7:06:16
 */
public class Test2 {
    /**
     * 开始测试
     * @param args
     */
    public static void main(String[] args) {
        MyDoubleLinkedDefin<Object> myList=new MyDoubleLinkedDefin<>();
        //按照顺序加入结点
        myList.add("第1个结点");
        myList.add("第2个结点");
        myList.add("第3个结点");
        myList.add("第4个结点");
        myList.add("第5个结点");
        myList.print();
        //在第三个索引值上插入一个结点
        myList.add(4,"第6个结点");
        myList.print();
        //移除一个结点
        System.out.println("--------remove测试---------");
        for(int i=0;i<6;i++){
            myList.remove(0);
            myList.print();
        }
    }
}

运行结果：

头结点：com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@6504e3b2
尾结点：com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
新加结点的前驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@6504e3b2
新加结点的后驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
新加结点的前驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@626b2d4a
新加结点的后驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
新加结点的前驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@5e91993f
新加结点的后驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
新加结点的前驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@1c4af82c
新加结点的后驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
新加结点的前驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@379619aa
新加结点的后驱结点:com.xfwl.algorithmAnalysis.linklsit.MyDoubleLinkedDefin$Node@515f550a
**************开始打印***************************
索引值：0，结点数据：第1个结点
索引值：1，结点数据：第2个结点
索引值：2，结点数据：第3个结点
索引值：3，结点数据：第4个结点
索引值：4，结点数据：第5个结点
***************打印结束**************************
**************开始打印***************************
索引值：0，结点数据：第1个结点
索引值：1，结点数据：第2个结点
索引值：2，结点数据：第3个结点
索引值：3，结点数据：第4个结点
索引值：4，结点数据：第6个结点
索引值：5，结点数据：第5个结点
***************打印结束**************************
--------remove测试---------
**************开始打印***************************
索引值：0，结点数据：第2个结点
索引值：1，结点数据：第3个结点
索引值：2，结点数据：第4个结点
索引值：3，结点数据：第6个结点
索引值：4，结点数据：第5个结点
***************打印结束**************************
**************开始打印***************************
索引值：0，结点数据：第3个结点
索引值：1，结点数据：第4个结点
索引值：2，结点数据：第6个结点
索引值：3，结点数据：第5个结点
***************打印结束**************************
**************开始打印***************************
索引值：0，结点数据：第4个结点
索引值：1，结点数据：第6个结点
索引值：2，结点数据：第5个结点
***************打印结束**************************
**************开始打印***************************
索引值：0，结点数据：第6个结点
索引值：1，结点数据：第5个结点
***************打印结束**************************
**************开始打印***************************
索引值：0，结点数据：第5个结点
***************打印结束**************************
当前双链表没有任何数据！

自认为代码注释的还算仔细的哈，如有不足，不吝指正！