链表(LinkedList)---永不过时的数据结构

链表的定义：

链表是一种物理上不一定连续，但是逻辑上连续的存储结构。

它可以解决在上一篇我们提到的顺序表的缺陷（在插入或删除元素的时间复杂度是O（n））。由于链表在物理上是不连续的，只需要修改元素的前后指向就可以了。因此，LinkList更适合随机的插入删除操作。

链表包含带头/不带头，单向/双向，循环/非循环这几种特性，这几种排列组合起来就有很多种模式了，比如带头+单向+循环、不带头+双向+循环、不带头+单向+非循环......

笔试面试时一般都是用不带头，单向，非循环这种类型的。

链表的模拟实现：

那我们来模拟实现一下链表吧：

package LinkedList;

public class LinkedList {
    public static class ListNode{
        public int data;
        public ListNode next;

        public ListNode(int data){
            this.data = data;
        }
    }

    public ListNode head;
    public LinkedList(){
        ListNode listNode1 = new ListNode(1);
        ListNode listNode2 = new ListNode(3);
        ListNode listNode3 = new ListNode(5);
        ListNode listNode4 = new ListNode(7);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        head = listNode1;
    }

    //头插法
    public void addFirst(int data){
        ListNode new_node = new ListNode(data);//先新建一个节点
        new_node.next = head;//（head一开始没数据，为null）
        head = new_node;//要将head的指向改变一下
    }

    //尾插法
    public void addLast(int data){
        if(head == null){//如果head为空，直接改变head
            head.data = data;
            return;
        }
        ListNode cur = head;//用于寻找最后一个指针的节点
        while(cur.next != null){//循环结束时，cur指向最后一个指针的节点
            cur = cur.next;
        }
        ListNode new_node = new ListNode(data);//新建一个节点
        cur.next = new_node;
    }

    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data){
        if(index < 0 || index >=this.size()){
            return false;//先判断插入到位置是否符合要求，这一点非常重要！！！
                         //公司面试时非常看重你有没有考虑到程序的 边界问题 错误处理 等各个方面。
        }

        if (index == 0) {
            addFirst(data);//如果在第0个位置插入数据，直接头插
            return true;
        }

        if (index == this.size()) {
            addLast(data);//如果在最后一个位置插入数据，直接尾插
            return true;
        }

        int count = 0;
        ListNode cur = head;

        while(count != index - 1){
            cur = cur.next;//循环结束后cur指向要插入位置的前一个节点
            count++;
        }

        ListNode new_node = new ListNode(data);
        new_node.next = cur.next;//要先改变新节点的next
        cur.next = new_node;//再改变cur的next！！！
        return true;
    }

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        ListNode cur = head;
        while(cur != null){
            if(cur.data == key){
                return true;
            }
        }
        return false;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        if(head == null){
            return;//如果链表为空，返回函数
        }
        if(head.data == key){
            head = head.next;//如果头节点为需要删除的节点，直接改变head的指向
            return;
        }
        ListNode cur = searchPrev(key);//找到key的前一个节点
        if(cur == null){//如果没找到返回函数
            return;
        }
        ListNode del = cur.next;//del是要删除的节点
        cur.next = del.next;//直接将cur的next指向要被删除的节点的下一个节点即可
    }

    public ListNode searchPrev(int key){
        ListNode cur = head;
        while(cur.next != null){
            if(cur.next.data == key){//如果下一个节点的data==key
                return cur;
            }
            cur = cur.next;
        }
        return null;//找不到
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        while(head.data == key && head != null){
            head = head.next;//如果头节点的值为key，修改头节点的指向
        }
        ListNode cur = head.next;
        ListNode prev = head;//prev指向cur的前一个节点
        while(cur != null){
            if(cur.data == key){
                prev.next = cur.next;//删除cur节点
            }
            else{
                prev = cur;//这一步加下面的cur = cur.next，可以将prev一直控制在cur的前一个节点
            }
            cur = cur.next;
        }
    }
    //得到单链表的长度
    public int size(){
        int count = 0;
        ListNode cur = head;
        while(cur != null){
            cur = cur.next;
            count++;
        }
        return count;
    }
    public void display(){
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    public void clear(){
        head = null;
    }
}

与顺序表的区别：

1. 链表是一种物理上不一定连续，但是逻辑上连续的存储结构。而顺序表是利用一段 连续的物理空间 来存储 相同类型数据元素 的结构。

2. 链表头插的时间复杂度为O(1)，而顺序表头插的时间复杂度为O(n)。

3. 链表不支持随机访问O(n)，而顺序表支持随机访问O(1)。

4. 链表没有容量的概念，而顺序表在插入元素时可能要扩容。

5. 链表常运用在需要大量插入删除的场景，而顺序表常运用在需要元素高效存储和大量随机访问的场景下。

在JAVA中的链表（LinkedList）：

在我们的JAVA中使用的就是无头双向链表：

在JAVA中还有一个特殊的节点，它记录着链表的个数、第一个节点的地址和最后一个节点的地址。

特殊节点在LinkedList原码中是这样的

以头插为例，在执行addFirst（）函数的时候，会修改头指针和尾指针的操作

一些常用方法：

构造函数

        //使用其他集合容器中元素构造List
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        arrayList.add(5);
        LinkedList<Integer> linkedList = new LinkedList<>(arrayList);

常用方法

遍历方式

LinkedList的遍历方法和ArrayList大相径庭，不过LinkedList还提供了反向遍历：

public class Text {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("What ");
        list.add("is ");
        list.add("your ");
        list.add("name ");
        list.add("? ");
        ListIterator<String> iterator = list.listIterator(list.size());
        while (iterator.hasPrevious()) {
            System.out.print(iterator.previous());
        }
    }
}

最后是每篇必有的正能量：

“父爱从不挂在嘴边，却用尽一生来诠释”_哔哩哔哩_bilibili