自定义简单实现LinkeList

原理

        LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的，所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。

LinkedList数据结构

LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,如下：

 
 

数组和链表结构对比

数组　是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少插入和删除元素，就应该用数组。

链表　中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储 数据元素 的　数据域，另一个是存储下一个结点地址的 指针。

　如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表。

内存存储区别

• 数组从栈中分配空间, 对于程序员方便快速,但自由度小
• 链表从堆中分配空间, 自由度大但申请管理比较麻烦

逻辑结构区别

数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。　

链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）　

总结

• 存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取
• 存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定
• 存储空间上，链表由于带有指针域，存储密度不如数组大
• 按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)
• 按值查找时，若数组无序，数组和链表时间复杂度均为O(1)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)
• 插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可
• 空间分配方面，数组在静态存储分配情形下，存储元素数量受限制，动态存储分配情形下，虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败；链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效

/**
 * 1.定义节点Node,size,firstNode,lastNode
 * 2.add方法
 *      2.1 创建节点,并给该节点赋值
 *      2.2 判断是否为首节点
 *          是-->给首节点赋值
 *          否-->将添加前的链表最后一个节点last赋值给给节点的pre
 *               将添加前的链表最后一个节点last的下一个节点赋值给该节点
 *      2.3 将该节点赋值给最后一个节点last
 * 3.remove方法
 *      3.1 获取删除节点
 *      3.2 删除的节点是否为首节点，
 *          是--> 将下一个节点设置为首节点
 *          否--> 旧节点的上一个节点赋值给新节点的上一个节点
 *                
 *      3.3 删除的节点是否为尾节点,
 *          是--> 将上一个节点设置为尾节点
 *          否--> 删除节点的上一个节点赋值给下一个节点的上一个节点
 */
public class LinkedListDemo<E> {
    //链表实际存储长度
    private int size;
    //第一个节点（为了查询开始）
    private Node<E> first;
    //最后一个节点（为了插入开始）
    private Node<E> last;

    //1.定义节点Node
    private class Node<E>{
        //存放元素的值
        public E item;
        //上一个节点Node
        public Node<E> prev;
        //下一个节点
        public Node<E> next;
    }

    //2.add方法
    public void add(E e){
        //创建节点
        Node<E> node = new Node<E>();
        //节点赋值
        node.item = e;
        //判断是否为首节点
        if(first == null){
            //给首节点赋值
            first = node;
        }else {
            //将添加前的链表最后一个节点last赋值给给节点的pre
            node.prev = last;
            //将添加前的链表最后一个节点last的下一个节点赋值给该节点
            last.next = node;
        }
        //将该节点赋值给最后一个节点last
        last = node;
        size++;
    }

    public void add(int index,E e){
        //获取原节点为旧节点
        Node<E> oldNode = getNode(index);
        if(oldNode != null){
            //赋值给新的节点
            Node<E> newNode = new Node<>();
            newNode.item = e;
            //获取旧节点的上一个节点prev
            Node oldPrevNode = oldNode.prev;
            if(oldPrevNode == null){
                //新节点为首节点
                first = newNode;
            }else {
                //旧节点的上一个节点赋值给新节点的上一个节点
                newNode.prev = oldPrevNode;
                //新节点赋值给旧节点的上一个节点的下一个节点
                oldPrevNode.next = newNode;
            }
            //该节点的下一个节点赋值给旧节点
            newNode.next = oldNode;
            //该节点赋值给旧节点的上一个节点
            oldNode.prev = newNode;
            size++;
        }else {
            add(e);
        }
    }

    public E remove(int index){
        //获取删除节点
        Node<E> removeNode = getNode(index);
        E removeNodeValue = removeNode.item;
        if(removeNode != null){
            //获取删除节点的上下节点
            Node<E> removePreNode = removeNode.prev;
            Node<E> removeNextNode = removeNode.next;
            if(removePreNode == null){
                //删除的为首节点，所以将下一个节点设置为首节点
                first = removeNextNode;
            }else {
                //删除节点的下一个节点赋值给上一个节点的下一个节点
                removePreNode.next = removeNextNode;
            }
            if(removeNextNode == null){
                //删除的为尾节点,所以将上一个节点设置为尾节点
                last =removePreNode;
            }else {
                //删除节点的上一个节点赋值给下一个节点的上一个节点
                removeNextNode.prev = removePreNode;
            }
            removeNode = null;
            size--;
        }
        return removeNodeValue;
    }

    public E get(int index){
        return getNode(index).item;
    }

    private Node<E> getNode(int index){
        //检查下标
        checkIndex(index);
        Node<E> node = new Node<E>();
        //如果有首节点
        if(first != null){
            //往后遍历index次
            node = first;
            for(int i = 0;i < index;i++){
                node = node.next;
            }
        }
        return node;
    }

    //检查下标
    private void checkIndex(int index){
        if(index < 0 && index >= size){
            throw new IndexOutOfBoundsException("查询越界啦！");
        }
    }

    public int size(){
        return size;
    }

}