java 链表基础详解

拨开链表迷雾

链表是基础的数据结构之一，和数组一样基础，提到链表我们总会联想到数组结构，最顺嘴的一句话便是数组适合查询，链表适合插入，但是这句话其实说的太过于简单，以至于就不是那么准确了，我们来细细分析下这句话。

数组适合查询？

数组适合查询这句话其实准确说应该是数组基于下标查询效率较高，时间复杂度是O(1)，如果用其值去数组中查询，效率也是不高的，时间复杂度和链表一样，是O(n)，所以我们在使用数组结构时，要学会利用其下标。

数组不适合写入？

数组不适合写入的原因有两个，第一是数组的内存分配，第二是数组的动态扩容需要对数据进行复制和移动。数组一但初始化内存大小就确定，可以联想数组的length，数据动态扩容需要对数组重新分配内存，将数据重新复制到新的内存里，所以数组的动态扩容是不适合写的根本原因。

链表适合写入？

链表适合写入最大的原因是链表并不需要连续的内存，而且链表的插入也不需要数据复制来复制去，链表中节点的连接是通过指针实现的。

所以单链表的插入只要找到要插入节点的前一个节点，只需要如下操作即可：

1. node3.next -> node2
2. node1.next -> node3

所以这么看来链表数据的插入根本不需要数据的复制，所以这才是链表适合插入的根本原因。

链表不适合查询？

这一点是毫无疑问的，因为链表没有像数组的索引的一个东西，所以无论是通过索引还是值在链表中查询都需要去遍历链表，时间复杂度是O(n)。

综上所有，数组适合查询，链表适合插入已经分析清楚了，数组和链表优点的优越性脱离条件没有任何意义。

遇见链表

上面已经分析了链表的优点和缺点，接下来我们来通过代码来遇见链表吧。

首先我来看一个最简单的单链表

public class Linked<T> {

    private class  Node<T> {

        public T t;

        public Node next;

        public Node(T t) {
            this(t,null);
        }

        public Node(T t,Node next) {
            this.t = t;
            this.next = next;
        }
    }

    private Node head;

    private int size;

    public Linked() {
        this.head = null;
        this.size = 0;
    }
}

这个链表暂时没有任何方法，只是内部有一个节点的内部类，然后两个成员变量，一个head，一个size。而内部类node也很简单，一个泛型代表节点内容，一个自身引用作为next，对于这个node类可以这样理解

前面我们也分析了链表是适合写的一个数据结构，那么接下来我们通过代码来看下链表的写入和删除。对于链表的插入和删除我一共设计了如下几个方法：

• addFirst 链表头部插入
• addLast 链表尾部插入
• add 指定位置插入
• delect 指定位置删除
• remove 删除指定元素

链表头部插入

/**
     * 链表头部添加元素
     * @param t
     */
    public void addFirst(T t){
        Node<T> node = new Node<T>(t);
        // 将新节点的next指向原来的头节点  newNode.next -> head
        node.next = this.head;
        // 将新节点赋值给头节点 newNode -> oldHead ->
        this.head = node;
        this.size ++;
    }

其实写链表的代码一个关键点是注意指针不要丢失，我在写链表时一般遵循一下两个步骤：

• 创建一个节点
• 将当前节点的next指向head
• 将当前节点赋值给head

指定位置插入

 /**
     * 指定位置插入
     * @param t
     * @param index
     */
    public void add(T t,int index){
        if (index < 0 || index > size){
            throw new IllegalArgumentException("index error");
        }

        if (index == 0){
            this.addFirst(t);
            return;
        }
        Node preNode = this.head;
        // 找到要插入的前一个节点
        for (int i = 0; i < index - 1; i++) {
            preNode = preNode.next;
        }

        //将链表链上
        Node node = new Node(t);
        // node - > next
        node.next = preNode.next;
        // pre - > node - > next
        preNode.next = node;
        this.size ++;
    }

指定位置插入按照如下步骤：

1. 找到指定位置的前一个节点
2. 将当前节点指向前一个节点的下一个节点
3. 将前一个节点指向当前节点

链表尾部插入

/**
     * 链表尾部添加元素
     * @param t
     */
    public void addLast(T t){
        this.add(t,this.size);
    }

指定位置删除

/**
     * 指定位置删除
     * @param index
     * @return
     */
    public Object delect(int index){

        if (index < 0 || index > size){
            throw new IllegalArgumentException("index error");
        }
        Object t = null;
        // 头节点删除
        if (index == 0){
            t = head.t;
            head = head.next;
            this.size --;
            return t;
        }

        // 找到要删除节点的前一个节点 和 后一个节点
        Node preNode = this.head;
        Node nextNode = this.head;
        int preIndex = index -1;
        for (int i = 0; i < index + 1; i++) {
            if (i < preIndex){
                preNode = preNode.next;
            }

            if (i == preIndex){
                nextNode = preNode;
                nextNode = nextNode .next;
                t = nextNode.t;
            }

            if (i == preIndex + 1){
                nextNode = nextNode.next;
            }
        }
        preNode.next = nextNode;
        this.size -- ;
        return t;
    }

指定位置删除的关键点逻辑是，将当前节点的前一个节点指向当前节点的下一个节点

删除指定元素

 /**
     * 删除指定元素
     * @param t
     */
    public void remove(T t){
        if (head == null){
            System.out.println("无元素可删除");
            return;
        }

        // 如何解决head不断重复的问题
        while (head != null && t.equals(head.t)) {
            head = head.next;
            this.size -- ;
        }

        if (head == null){
            System.out.println("无元素可删除");
            return;
        }

        Node currNode = head;
        while (currNode.next != null){
            if (currNode.next.t.equals(t)){
                currNode.next = currNode.next.next;
                this.size --;
            }else {
                currNode = currNode.next;
            }
        }
    }

删除指定元素与删除指定位置的数据的区别就在于如何定位到数据。

以上就是链表的插入和删除操作，为了进一步深入链表的使用，我洗的了一个基于链表实现的lru算法，链表中存入最近使用的10个元素。

/**
 *
 * @author wengyz
 * @version LRUUtil.java, v 0.1 2020-02-09 16:38
 */
public class LRUUtil {

    public static volatile Linked<String> list = new Linked<String>();

    /**
     * lru算法添加
     * @param t
     */
    public static void add(String t){
        // 删除指定元素
        if (list.getSize() != 0){
            list.remove(t);
        }
        // 判断容量，假设只能存10个，删除最后一个元素
        if (list.getSize() == 10){
            list.delect(9);
        }
        // 将当前元素添加到最前面
        list.addFirst(t);
    }

    /**
     * lru使用
     * @param t
     */
    public static void use(String t){
        add(t);
    }
}

总结

本文主要分析了链表结构，写了一些链表的插入和删除demo，最后写了一个基于链表的lru算法。

扫码关注个人公众号