Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍

文章目录

  • 一、模拟实现单链表
    • 1, 什么是链表
    • 2, 成员属性
    • 3, 成员方法
      • 0,构造方法
      • 1,addFirst——头插
      • 2,addLast——尾插
      • 3,addIndex——在任意位置插入
        • 3.1,checkIndex——判断index合法性
        • 3.2,findPrevIndex——找到index-1位置的结点
      • 4,contains——判定是否包含某个元素
      • 5, remove——删除第一次出现关键字为key的结点
        • 5.1, findPrevKey——找到key结点的前一个结点
      • 6, removeAll——删除所有值为key的结点
      • 7,size——获取单链表长度
      • 8,clear——清空单链表
      • 9,display——打印链表
  • 二、Java提供的LinkedList
    • 1,LinkedList 的说明
    • 2,使用LinkedList
      • 2.1,LinkedList 实例化方式
      • 2.2,LinkedList 常用方法
    • 链表和顺序表对比
  • 总结

各位读者好, 我是小陈, 这是我的个人主页
小陈还在持续努力学习编程, 努力通过博客输出所学知识
如果本篇对你有帮助, 烦请点赞关注支持一波, 感激不尽
希望我的专栏能够帮助到你:
JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管理系统等
Java数据结构: 顺序表, 链表, 堆, 二叉树, 二叉搜索树, 哈希表等
JavaEE初阶: 多线程, 网络编程, TCP/IP协议, HTTP协议, Tomcat, Servlet, Linux, JVM等(正在持续更新)


提示:是正在努力进步的小菜鸟一只,如有大佬发现文章欠佳之处欢迎评论区指点~ 废话不多说,直接发车~

一、模拟实现单链表

1, 什么是链表

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

说人话:链表就是 “链接” 起来的。可以理解为火车,火车是由一节节车厢 “链接” 而成的;而链表,是由一个个结点/节点 “链接” 而成的

链表的结构可以细分为八种;我们主要掌握两种即可
1️⃣无头单向非循环
结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多

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

❓为什么要模拟实现:
自己模拟实现 简易版的 顺序表的增删查改等主要功能,大致理解顺序表的设计思想
再对比学习 Java 提供的集合类当中的 LinkedList,在学习 Java 的 LinkedList 常用方法的同时,也能学习源码的思想



我们模拟实现的是 无头单向非循环 链表

2, 成员属性

Java 中的 LinkedList 是集合框架中的一个类,要模拟实现链表,也得自己实现一个类,首先要考虑这个类中的成员属性

已经说过,链表是由结点 “链接” 而成的,那么需要定义一个 静态内部类 Node:其中有两个域:
值域 value :来记录这个结点的值
指针域 next:来记录下一个结点的地址

还需要一个 成员变量:head 来记录当前链表的头结点

为了方便测试,全部设置为 public

public class MyLinkList {

    // 静态内部类,不依赖于链表对象,可以单独存在
    static class Node {
        public int value;
        public Node next;// Node类型的next值,存放下一个节点的地址

        public Node(int value) {
            this.value = value;
        }
    }
        public Node head;// 链表的头节点

⚠️模拟实现重在理解理想,为了简便,不使用泛型,数组中存放 int 类型


3, 成员方法

// 无头单向非循环链表实现
	public class MyLinkList {
		// 1,头插
		public void addFirst(int data){}
		// 2,尾插
		public void addLast(int data){}
		// 3,任意位置插入,第一个数据节点为0号下标
		public void addIndex(int index,int data){}
		// 4,查找是否包含关键字key是否在单链表当中
		public boolean contains(int key){}
		// 5,删除第一次出现关键字为key的节点
		public void remove(int key){}
		// 6,删除所有值为key的节点
		public void removeAllKey(int key){}
		// 7,得到单链表的长度
		public int size(){}
		// 8,清空链表
		public void clear() {}
		// 9,打印(官方没有这个方法,写出来方便我们自己测试)
		public void display() {}
}

0,构造方法

模拟的链表的这个类中构造方法只有内部类 Node 的构造方法,只用来对结点的 value 域赋值即可,指针域 next 不赋值,默认为 null ,在相应的方法内修改 Node 的指针域 next

    // 静态内部类,不依赖于链表对象,可以单独存在
    static class Node {
        public int value;
        public Node next;// Node类型的next值,存放下一个节点的地址

        public Node(int value) {
            this.value = value;
        }
    } 

1,addFirst——头插

❗️❗️和顺序表不同,链表是由一个个结点组成的,而顺序表可以理解为一个数组
顺序表插入之前必须考虑数组是否以及满了,而链表只需要关心各个结点的next即可

我们还有一个成员属性:head,是用来记录头结点的
链表的头插操作就是:
1️⃣new 一个结点 node,类型是 Node
2️⃣链接:把头结点的地址( head 的值)赋给 node 的指针域 next
3️⃣head 记录新的头结点

    public void addFirst(int value) {
        Node node = new Node(value);
        node.next = head;
        head = node;
    }

2,addLast——尾插

尾插步骤:
1️⃣new 一个 node,类型是 Node
2️⃣找到尾结点
3️⃣链接:把 node 的值(也就是地址)赋给尾结点的指针域 next


如何找到尾结点呢❓
需要 从头结点开始,遍历链表,找到一个结点的指针域 next 域为 null,它就是尾结点✅

head 是用来标记头结点的,所以 head 不能随意更改
我们需要再定义一个 Node 类型的 cur,让 cur 遍历链表

当 cur 找到尾结点后,需要让此时的尾结点和新结点 node 连接上
即:

		cur.next = node;

如图:
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍_第1张图片

既然 cur 从头开始遍历链表

		Node cur = head;

遍历链表的过程就是一个循环♻️,如果 cur.next == null 时跳出循环
如果不满足条件,说明cur此时不是尾结点,那么cur要往下走,如何实现呢❓

cur 这个变量中存放的值 要更改为下一个结点的地址:cur = cur.next;

写到这里就要小心了❗️❗️
cur.next这一句代码是要访问 cur 的 next 域,如果 cur == null 时,这里就会发生空指针异常❌

那么有没有可能会这种情况呢?
cur 是从 head 开始往后遍历的,那么如果 head 一开始就是 null ,也就是链表为空时,cur 就会被 head 赋值成 null,就会发生空指针异常
所以当链表为空时,就不需要遍历链表找尾结点,直接把 node 的值赋给 head 即可


完整代码:

    public void addLast(int value) {
        Node node = new Node(value);
        // 链表为空的情况
        if (head == null) {
            head = node;
            return;
        }
        Node cur = head;
        // 找到最后一个结点的位置
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

3,addIndex——在任意位置插入

官方规定第一个数据的位置是0,和数组的位置(下标)规则一致

第一个参数就是 index,首先要判断 index 的合法性

3.1,checkIndex——判断index合法性

index<0 || index >链表长度是不合法❌的

   public void checkIndex(int index) {
        if (index < 0 || index > size()) {
        // size()方法获取链表长度,遍历链表即可,比较简单,不多赘述
            throw new LinkListIndexOutOfException("这个位置不合法");
            // 异常处理
        }
    }

index 合法的情况下,如何在index位置插入删除呢❓
index == 0就是头插
index = 链表长度就是尾插
❗️主要是链表中间位置的插入和删除
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍_第2张图片
要想在两个结点中间插入新结点,首先要找到这两个结点的地址
找到 index -1 结点的位置也就相当于找到了 index 结点的位置

3.2,findPrevIndex——找到index-1位置的结点
  public Node findPrevIndex(int index) {
        Node cur = head;
        int count = 0;
        while (count != index - 1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

代码实现很简单,cur 遍历链表 index-1 次即可


具体插入步骤:
1️⃣node.next = prevIndex.next;
2️⃣prevIndex.next = node;

这两行不能交换位置❗️❗️❗️
如果先让 prevIndex.next = node;那么就会丢失 index 位置的那个结点↪️,此时 node.next = prevIndex.next 就相当于 node.next = node;代码会发生错误❌

完整代码:

	public void addIndex(int index, int value) {
        // 先检查index参数是否合法
        checkIndex(index);
        // 如果index == 0;头插即可
        if (index == 0) {
            addFirst(value);
            return;
        }
        // 如果index == size;尾插即可
        if (index == size()) {
            addLast(value);
            return;
        }

        // 中间插入删除
        Node node = new Node(value);
        // 先找到index-1位置的结点
        Node prevIndex = findPrevIndex(index);
        node.next = prevIndex.next;
        prevIndex.next = node;
    }

4,contains——判定是否包含某个元素

比较简单,遍历这个数组即可

   public boolean contain(int key) {
        Node cur = head;
        while (cur != null) {
            if (cur.value == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

因为这里我们存放的是 int 类型的变量,但 LinkedList 当中可以存放引用数据类型的
⚠️⚠️⚠️当表中是引用类型时,就不可以用“等号”比较,应该用 equals 方法


5, remove——删除第一次出现关键字为key的结点

1️⃣如果链表为空就不能再删了
2️⃣如果头结点就是要删除的 key 结点,直接 head 存放下一个结点的地址
3️⃣如果链表其他结点是要删除的 key 结点,要先找到 key 结点的前一个结点

5.1, findPrevKey——找到key结点的前一个结点
  // 找到key的前一个结点
    public Node findPrevKey(int key) {
        Node cur = head;
        while (cur.next != null) {
            // 注意循环判断条件  如果cur.next==null 说明cur此时是最后一个节点
            // 如果再访问下一个结点的value值,会空指针异常
            // 此时的cur的value值在上一次循环以及判断过了,所以cur走到最后一个结点时,是最后一趟循环
            if (cur.next.value == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

返回找到的这个结点即可


删除过程如图:
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍_第3张图片

当 key 结点的前一个结点的 next 不再存放 key 结点地址时,key 结点此后不会再被使用,会被系统自动回收️

完整代码如下:

 public void remove(int key) {
        // 如果链表为空
        if (head == null) {
            return;
        }
        // 如果头结点就是key
        if (head.value == key) {
            head = head.next;
            return;
        }
        // 首先要找到key的前一个结点
        Node prevKey = findPrevKey(key);
        if (prevKey == null) {
            return;
        }
        // 重新链接
        Node del = prevKey.next;
        prevKey.next = del.next;
    }

6, removeAll——删除所有值为key的结点

这里需要一个 prevCur 结点来记录 cur 的前一个结点
当 cur 是 key 结点时,key结点的前一个结点(也就是 prevCur)可以直接断开和 key 结点的链接,指向 key 结点的下一个

利用循环♻️操作每个结点的 next 即可

    public void removeAll(int key) {
        // 如果链表为空
        if (head == null) {
            return;
        }

        Node prevCur = head;
        Node cur = head.next;
        while (cur != null) {
            if (cur.value == key) {
                prevCur.next = cur.next;
                cur = cur.next;
            } else {
                prevCur = cur;
                cur = cur.next;
            }
        }

        // 如果头结点就是key
        if (head.value == key) {
            head = head.next;
        }
    }


7,size——获取单链表长度

直接遍历链表即可

    public int size() {
        Node cur = head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

8,clear——清空单链表

head 这个变量一直存放着链表的头结点位置,把head置空,就找不到此链表,那么链表中的所有结点都会被系统自动回收️

    public void clear() {
        head = null;
    }

9,display——打印链表

注意:LinkedList 中不存在该方法,为了方便看测试结果

     public void disPlay() {
        Node cur = head;
        while (cur != null) {
            System.out.print(cur.value + " ");
            cur = cur.next;
        }
        System.out.println();
    }

二、Java提供的LinkedList

1,LinkedList 的说明

Java官方的集合框架中,LinkedList 是一个普通的类,继承了List接口
LinkedList 的底层是双向链表结构,由于链表没有将元素存储在连续的空间中,元素存储在单独的结点中,然后通过引用将结点连接起来了,因此在在任意位置插入或者删除元素时,不需要搬移元素,效率比较高。

⚠️特殊说明:
1️⃣LinkedList 实现了List接口
2️⃣LinkedList 的底层使用了双向链表
3️⃣LinkedList 没有实现 RandomAccess 接口,因此 LinkedList 不支持随机访问
4️⃣LinkedList 的任意位置插入和删除元素时效率比较高,时间复杂度为O(1)
5️⃣LinkedList 比较适合任意位置插入的场景


2,使用LinkedList

2.1,LinkedList 实例化方式

1️⃣无参构造法

        LinkedList <Integer> linkedList = new LinkedList <>();

2️⃣有参数——参数是其他 Collection
Collection是集合框架中的一个接口,实现了这个接口的类的对象就可以作为参数,说白了就是
可以把其他的顺序表,链表,栈,队列等等 作为参数传参,例如:

		ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        LinkedList<Integer> linkedList= new LinkedList<arrayList >(arrayList );

我先 new 了一个顺序表对象 arrayList ,在这个表中插入了 “1” “2” 两个数据,顺序表中的数据是顺序存储的
当 arrayList 作为参数传递时,linkedList 对象中就有了 arrayList 中的所有数据,linkedList 中的数据是链式存储❗️的


2.2,LinkedList 常用方法

在 main 方法中展示使用方式:

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        // 1,插入(默认是尾插)
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.add(4);
        linkedList.add(5);
        System.out.println("1,尾插后:" + linkedList);

        // 2,任意位置插入
        linkedList.add(0, -1);
        System.out.println("2,在0位置插入后:" + linkedList);

        // 先new一个顺序表对象
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        // 3,插入其他Collection的所有元素(尾插)
        linkedList.addAll(arrayList);
        System.out.println("3,插入arrayLsit所有数据后:" + linkedList);

        // 4,删除任意位置的数据
        linkedList.remove(0);
        System.out.println("4,删除0位置数据后:" + linkedList);

        // 5,删除任意数据
        linkedList.remove(new Integer(1));
        System.out.println("5,删除1后:" + linkedList);

        // 6,获取任意位置的数据
        int ret = linkedList.get(0);
        System.out.println("6,获取0位置的数据:" + ret);

        // 7,更改任意位置的数据
        linkedList.set(0, 100);
        System.out.println("7,把0位置的数据更改为100后:" + linkedList);

        // 8,查看链表中是否存在该数据
        boolean bl = linkedList.contains(100);
        System.out.println("8,查看链表中是否存在100这个数据:" + bl);

        // 9,获取链表中任意数据第一次出现的位置
        int index = linkedList.indexOf(3);
        System.out.println("9,3这个数据第一次出现的位置:" + index);

        // 10,获取链表中任意数据最后一次出现的位置
        int lastIndex = linkedList.lastIndexOf(3);
        System.out.println("10,3这个数据最后一次出现的位置:" + lastIndex);

        // 11,截取
        List<Integer> list = linkedList.subList(1, 3);// 左闭右开
        System.out.println("11,截取linkedList中从1到3的数据:" + list);

        // 12,清空
        linkedList.clear();
        System.out.println("12,清空linkedList后:" + linkedList);
    }
}

运行结果:
Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍_第4张图片

链表和顺序表对比

Java【链表】详细图解/ 模拟实现+【LinkedList】常用方法介绍_第5张图片
链表和顺序表都有各自的优缺点,并且这两种结构的优缺点基本是互补的,所以不存在哪一种结构更优秀,只有在不同的场景,会有更加合适的结构。


总结

以上就是今天分享的关于数据结构中【链表】的内容,
一方面介绍了如何模拟实现简易的单链表,
一方面介绍了Java集合框架中的【LInkedList】类的基本使用,
并且分析了链表和顺序表的区别对比

如果本篇对你有帮助,请点赞收藏支持一下,小手一抖就是对作者莫大的鼓励啦


上山总比下山辛苦
下篇文章见

你可能感兴趣的:(数据结构,java,链表,数据结构)