前言

本篇博客给大家带来的是链表的知识点, 其中包括面试经常会提问的真题 ArrayList 和 LinkedList 的区别 .

文章专栏: Java-数据结构

若有问题 评论区见

欢迎大家点赞 评论 收藏 分享

如果你不知道分享给谁,那就分享给薯条, 如果分享不成功, 那我就会回你一下,那样你就分享成功啦.

你们的支持是我不断创作的动力 .

1.ArrayList的存在的问题

1.ArrayList底层使用连续的空间, 任意位置插入或者删除元素时, 需要将该位置后面的元素整体往前或往后移动,故时间复杂度为 O(N) .

2.增容需要申请新的空间, 拷贝数据, 释放旧空间 会有不小的消耗 .

3.增容一般是呈1.5倍或2倍增长,势必会有一定的空间浪费. 例如当前容量为100时, 假设呈二倍增长,满了以后增容到200, 我们再继续插入5个数据, 后面没有数据插入的话就浪费了95个数据空间.

如果我们想要达到那种随用随取, 有几个数据我就增几个空间,那我们该怎么办呢? - 就是今天要介绍的链表了

2.链表

2.1链表的概念及结构

链表是一种 物理存储结构上非连续存储结构, 数据元素的 逻辑顺序 是通过链表种的引用链接次序实现的.

注意: 

1. 从上图可看出, 链式结构再逻辑上是连续的的,但是在物理上不一定连续.

2. 现实中的结点一般都是从堆上申请出来的

3. 从堆上申请的空间, 是按照一定的策略来分配的, 两次申请的空间可能连续, 也可能不连续

实际中链表的结构非常多样, 一下情况组合起来就有8种链表结构 :

1. 单向或者双向

2.带头或者不带头

3.循环或者非循环

虽然有8种链表的结构, 但是我们重点掌握两种: 

1.无头单向非循环链表: 结构简单, 一般不会单独用来存数据. 实际种更多的是作为其他数据结构的子结构, 如: 哈希桶, 图的邻接表等等. 另外这种结构在笔试 面试中出现很多.

2.无头双向链表: 在Java的集合框架库中LinkedList 底层实现 就是无头双向循环链表.

2.2链表的实现(无头单向非循环链表)

写到这里, 我想起上篇 顺序表的实现 , 我直接把代码一丢 没做任何解释, 会让初学者看得很难受, 所以这次我得改正这个错误, 尽量让大家都能看懂并且会自己写. 其实解释也是很耗费时间的, 作为一名大二的学生😭, 上专业课和看网课就让我的时间所剩无几, 完后还要写blog, 我真是累成狗了🐶. 但是我还是很开心的,  一方面能够给大家带来知识, 另一方面也是在巩固我的知识. 

第一步创建一个类 MySingleList 

 我们都知道节点是链表里面的 , 所以节点就是链表的成员,这没有问题,

那问题来了, 节点中的数据data呢? 它可以定义为链表的成员吗? 

显然是不行的, 因为data是节点里面的, 只需要,在MySingleList类当中再定义一个内部类ListNode就可以解决了.

public class MySingleList {

    //因为节点是链表的一部分,所以可以将其定义为内部类
    static class ListNode {
        public int val;//节点的值域
        public ListNode next;//下一个节点的地址

        public ListNode(int val) {
            this.val = val;
        }
    }
public ListNode head;//表示当前链表的头节点
}

所以有了上述代码. 那么接着我想要实现链表的头插法, 尾插法. 我发现没有链表,

那么就自己手动实现一个简单点的,

// 头插法
public void addFirst ( int data ){
}
// 尾插法
public void addLast ( int data ){
} 
public class MySingleList {

    //因为节点是链表的一部分,所以可以将其定义为内部类
    static class ListNode {
        public int val;//节点的值域
        public ListNode next;//下一个节点的地址

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

public ListNode head;//表示当前链表的头节点

//手动实现简单链表
public  void createList() {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        this.head = node1;
    }
}
好,  到这里 我们就可以来实现链表的基本操作: 

第二步实现链表的基本操作

遍历单链表:

//遍历单链表
    public void display() {
        //指向头节点的引用不能动,所以利用cur代替
        ListNode cur = this.head;
        while(cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

求链表的长度:

//得到单链表的长度
    public int size(){
        int count = 0;
        ListNode cur = this.head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

查找关键字key是否包含在链表中:

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

头插法:

//头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

尾插法:

public void addLast(int data) {
        ListNode node = new ListNode(data);
        ListNode  cur = this.head;
        if(cur == null) {
            head = node;
            return;
        }
        while(cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
        node.next = null;
    }

任意位置插入,第一个数据节点为0号下标: 

//任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        if(index < 0 || index > size()) {
            System.out.println("index 不合法");
            return;
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        int count = 0;
        ListNode node = new ListNode(data);
        ListNode cur = this.head;
        while(count != index-1) {
            cur = cur.next;
            count++;
        }
        node.next = cur.next;
        cur.next = node;
    }

清除链表, 直接把head赋值为空即可:

//清除单链表
    public void clear() {
        this.head = null;
    }

删除第一个值为key的节点:

//删除第一个关键字为key的节点
    public void remove(int key){
        if(head == null) {
            return;
        }
        //单独删除头节点
        if(head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = searchPrev(key);
        if(cur == null) {
            System.out.println("没有找到key");
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    //找到关键字key的前驱
    private ListNode searchPrev(int key) {
        ListNode cur = this.head;
        while(cur.next != null) {
            if(cur.next.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

删除值为key的所有节点:

 //删除所有关键为key的节点
    public void removeAll(int key){
        if(head == null) {
            return;
        }

        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while(cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key) {
            head = head.next;
        }
    }

下面是全部代码:

//因为节点是链表的一部分,所以可以将其定义为内部类
    static class ListNode {
        public int val;//节点的值域
        public ListNode next;//下一个节点的地址

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

    public ListNode head;//表示当前链表的头节点

    public  void createList() {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        this.head = node1;
    }

    //遍历单链表
    public void display() {
        //指向头节点的引用不能动,所以利用cur代替
        ListNode cur = this.head;
        while(cur != null) {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

    //得到单链表的长度
    public int size(){
        int count = 0;
        ListNode cur = this.head;
        while(cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

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

        //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

        //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        ListNode  cur = this.head;
        if(cur == null) {
            head = node;
            return;
        }
        while(cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
        node.next = null;
    }

        //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        if(index < 0 || index > size()) {
            System.out.println("index 不合法");
            return;
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        int count = 0;
        ListNode node = new ListNode(data);
        ListNode cur = this.head;
        while(count != index-1) {
            cur = cur.next;
            count++;
        }
        node.next = cur.next;
        cur.next = node;
    }

        //删除第一个关键字为key的节点
    public void remove(int key){
        if(head == null) {
            return;
        }
        //单独删除头节点
        if(head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = searchPrev(key);
        if(cur == null) {
            System.out.println("没有找到key");
            return;
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    //找到关键字key的前驱
    private ListNode searchPrev(int key) {
        ListNode cur = this.head;
        while(cur.next != null) {
            if(cur.next.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    //删除所有关键为key的节点
    public void removeAll(int key){
        if(head == null) {
            return;
        }

        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while(cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key) {
            head = head.next;
        }
    }

    //清除单链表
    public void clear() {
        this.head = null;
    }

3.LinkedList的模拟实现(无头双向链表)

无头双向链表跟上述的单向链表的实现大致相同,不过是多了一个前驱,故不做解释

static class ListNode {
        private int val;//数据域
        private ListNode prev;//前驱
        private ListNode next;//后继

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;//双向链表的头节点.
    public ListNode last;//双向链表的尾节点.

    //头插法
    public void addFirst(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            head = node;
            last = node;
        }else{
            head.prev = node;
            node.next = head;
            head = node;
        }
    }

    //尾插法
    public void addLast(int data){
        ListNode node = new ListNode(data);
        if(head == null) {
            last = node;
            head = node;
        }else {
            last.next = node;
            node.prev = last;
            last = node;
        }
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data){
        ListNode node = new ListNode(data);
        ListNode cur = head;
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        if(index != 0 && index != size()) {
            for (int i = 0; i < index-1; i++) {
                cur = cur.next;
            }
            node.next = cur.next;
            cur.next.prev = node;
            cur.next = node;
            node.prev = cur;
        }

    }
//判断Index是否合法
    private void checkIndex(int index) {
        if(index < 0 || index > size()) {
            throw new IndexOutOfException("index 不合法" + index);
        }
    }

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

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        ListNode cur = head;
        if(head.val == key) {
            head = head.next;
            if(head != null) {
                //考虑只有一个节点的情况下
                head.prev = null;
            }else{
                last = null;
            }
            return;
        }
        if(last.val == key) {
            last = last.prev;
            last.next = null;
            return;
        }
        while(cur != null) {
            if(cur.val == key) {
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
                return;
            }
            cur = cur.next;
        }
    }

    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode cur = head;
        while(cur != null) {
            if(cur.val == key) {
                if(cur == head) {
                    head = head.next;
                    head.prev = null;
                    cur = cur.next;
                    continue;
                }
                if(cur == last) {
                    last = last.prev;
                    last.next = null;
                    cur = cur.next;
                    continue;
                }
                cur.prev.next = cur.next;
                cur.next.prev = cur.prev;
                cur = cur.next;
            }
            cur = cur.next;
        }
    }

    //得到链表的长度
    public int size(){
        ListNode cur = head;
        int count = 0;
        while(cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

    //遍历链表
    public void display(){
        ListNode cur = head;
        for (int i = 0; i < size(); i++) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //清除链表
    public void clear(){
        /*ListNode cur = head;
        while(cur.next != null) {
            cur = cur.next;
            cur.prev.next = null;
            cur.prev = null;
        }
        //while循环走出来有两种情况:
        //1.head.next = null;
        //2.cur走到了尾节点.
        if(head.next == null) {
            head = head.next;
        }else {
            cur.prev = null;
        }
        head = null;
        last = null;*/

        //gaobo写法:
        ListNode cur = head;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.prev = null;
            cur.next = null;
            cur = curNext;
        }
        head = null;
        last = null;
    }

4.LinkedList的使用

4.1LinkedList的介绍

LinkedList的官方文档:

LinkedList (Java Platform SE 8 ) (oracle.com)

由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

说明:

1. LinkedList实现了List接口

2. LinkedList的底层使用了双向链表

3. LinkedList没有实现RandomAccess接口, 因此LinkedList不支持随机访问

4. LinkedList的任意位置插入和删除元素时的效率比较高,时间复杂度为O(1)

5. LinkedList比较适合任意位置插入的场景

4.2LinkedList的使用

1.LinkedList的构造

public class Test3 {
    public static void main(String[] args) {
        //构造一个空的LinkedList
        List<Integer> list1 = new LinkedList<>();

        List<String> list2 = new ArrayList<>();
        list2.add("2334");
        list2.add("ieie");
        list2.add("uuy");

        //使用ArrayList构造LinkedList
        List<String> list3 = new LinkedList<>(list2);
        System.out.println(list3);
    }
}

第二种构造方法与 顺序表中第二种构造方法相似. 这里看不懂的可以去上篇看看顺序表中关于构造方法的讲解.

2.LinekedList的其他常用方法

int indexOf(Object o)    返回第一个o所在下标    
int lastlndexOf(Object 0)    返回最后一个o的下标    
List<E> subList(int fromlndex, int tolndex)    截取部分 list

5.ArrayList和LinkedList的区别

从不同点处记忆即可

# 数据结构 # 链表
Logo
松山湖开发者村综合服务平台

助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台

更多推荐

cover

基于YOLOv8深度学习的智慧农业柑橘病害识别检测系统(PyQt5界面+数据集+训练代码)

avatar 松山湖开发者村综合服务平台
cover

【Kafka】与【Hadoop】的集成应用案例深度解析

avatar 松山湖开发者村综合服务平台
cover

SpringBoot 整合 RabbitMQ

avatar 松山湖开发者村综合服务平台