手写LinkedList集合简易版

手写LinkedList集合的简易版

为了加深自己对LinkedList集合数据结构的理解和底层原理的实现，参考一些资料手写了一个简易版的LinkedList集合，将自己的容易遗漏的知识点记录下来，方便以后自己回顾。

LinkedList原理

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

LinkedList数据结构原理

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

既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，如下图所示：

数组和链表结构对比

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

链表　中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储 数据元素 的　数据域，另一个是存储下一个结点地址的 指针。
　如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表。

内存存储区别

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

逻辑结构区别

数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。　
链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）

1、自定义list集合

package com.zzw.list;

/**
 * @author zzw
 * @version 1.0
 * @description 自定义list接口
 * @modifiedBy
 */
public interface ExtList<E> {

    void add(E e);

    void add(int index, E e);

    E remove(int index);

    boolean remove(Object e);

    int getSize();

    E get(int index);
}

2、自定义实现LinkedList集合

package com.zzw.list;

import com.zzw.list.ExtList;

/**
 * @author zzw
 * @version 1.0
 * @description 自定义实现LinkedList
 * @modifiedBy
 */
public class ExtLinkedList<E> implements ExtList<E> {

    // 链表实际存储元素
    private int size;
    // 第一个元素(头节点,为了查询开始)
    private Node first;
    // 最后一个元素(头节点,为添加开始)
    private Node last;

    public void add(E e) {
        // 创建节点
        Node node = new Node();
        // 给节点赋值
        node.object = e;
        if (first == null) {
            // 添加第一个元素
            // 给第一个元素赋值node节点赋值
            first = node;
            // 第一个元素头和尾都属于自己
        } else {
            // 添加第二个或以上数据
            node.prev = last;
            // 将上一个元素的next赋值
            last.next = node;
        }
        last = node;
        // 实际长度++FF
        size++;

    }

    public void add(int index, E e) {
        // 下标的验证
        checkElementIndex(index);
        // node2节点
        ExtLinkedList<E>.Node oldNode = getNode(index);
        if (oldNode != null) {
            // node1
            ExtLinkedList<E>.Node oldPrevNode = oldNode.prev;
            // node4
            Node newNode = new Node();
            newNode.object = e;
            // node 4下一个节点node2
            newNode.next = oldNode;
            if (oldPrevNode == null) {
                first = newNode;
            } else {
                // node 4上一个节点node1
                newNode.prev = oldPrevNode;
                // node1的下一个节点node4
                oldPrevNode.next = newNode;
            }
            // node2 上一个节点变为node4
            oldNode.prev = newNode;
            size++;
        }

    }

    public E remove(int index) {
        checkElementIndex(index);
        // 1.先获取当前删除Node节点
        ExtLinkedList<E>.Node oldNode = getNode(index);
        boolean flag= remove((E) oldNode);
        if(!flag){
            throw new IllegalArgumentException("删除失败");
        }
        return (E) oldNode;
    }

    public boolean remove(Object e) {
        ExtLinkedList<E>.Node oldNode = (Node) e;
        if (oldNode != null) {
            // 2.获取删除元素的上下节点
            // node3
            ExtLinkedList<E>.Node oldNextNode = oldNode.next;
            // node1
            ExtLinkedList<E>.Node oldPrevNode = oldNode.prev;
            // 将node1 的下一个节点变为node3
            if (oldPrevNode == null) {
                // 删除一个元素 从换换头
                first = oldNextNode;
            } else {
                oldPrevNode.next = oldNextNode;
                oldNode.prev = null;
            }
            // 将node3的上一个节点变为node1
            if (oldNextNode == null) {
                last = oldPrevNode;
            } else {
                oldNextNode.prev = oldPrevNode;
                oldNode.next = null;
            }
            oldNode.object = null;// 让垃圾回收机制回收
            size--;
            return true;
        }
        return false;
    }

    public int getSize() {
        return size;
    }

    public E get(int index) {
        // 下标的验证
        checkElementIndex(index);
        return (E) getNode(index).object;
    }

    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException("查询越界啦！");
        }

    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    /*
     * @author zzw
     * @description 通过下标查找节点
     * @params index 节点下标
     * @return 节点
     **/

    public Node getNode(int index) {
        // 下标的验证
        checkElementIndex(index);
        Node node = null;
        if (first != null) {
            node = first;// 默认取第0个
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        }
        return node;
    }


    // 双向链表节点存储元素
    private class Node {
        // 存放元素的值
        Object object;
        // 上一个节点Node
        Node prev;
        // 下一个节点Node
        Node next;

    }
}

3、测试用例

package com.zzw.list;

import java.util.LinkedList;
import java.util.List;

/**
 * @author zzw
 * @version 1.0
 * @description ${description}
 * @modifiedBy
 */
public class Test01 {

    public static void main(String[] args) {
        ExtLinkedList<String> extLinkedList = new ExtLinkedList<String>();
        extLinkedList.add("a");
        extLinkedList.add("b");
        extLinkedList.add("c");
        extLinkedList.add("e");
        System.out.println("---------原数组--------------------");
        print(extLinkedList);
        System.out.println("---------添加后f--------------------");
        extLinkedList.add(3, "f");
        print(extLinkedList);
        System.out.println("---------删除b--------------------");
        extLinkedList.remove(1);
        print(extLinkedList);
    }

    public static void print(ExtList list){
        for (int i = 0; i < list.getSize(); i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
    }
}

4、运行结果

---------原数组--------------------
abce
---------添加后f--------------------
abcfe
---------删除b--------------------
acfe

总结

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