第六章 LinkedList与链表

于 2023-05-26 11:53:55 发布
阅读量742 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45698983/article/details/130884000
版权

1. ArrayList的缺陷

ArrayList底层使用数组来存储元素，由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。
因此：java集合中又引入了LinkedList，即链表结构。

2. 链表

2.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
image.png
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向

image.png

  1. 带头或者不带头

image.png

  1. 循环或者非循环

image.png
重点掌握两种:

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

image.png

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

2.2 链表的实现

public class MySingleList {

    static class ListNode {
        public int val;     // 节点的值域
        public ListNode next;   // 下一个节点的地址

        public ListNode(int val) {

            this.val = val;
        }
    }

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

    public ListNode creatList() {

        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);

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

        this.head = node1;

        return head;
    }

    public void display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //得到单链表的长度
    public int size() {

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

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {

        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                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 = head;

        if (cur == null) {
            head = node;
        } else {
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    //任意位置插入,第一个数据节点为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;
        }

        ListNode cur = findIndexSubOne(index);
        ListNode node = new ListNode(data);

        node.next = cur.next;
        cur.next = node;
    }

    // 找到index位置
    private ListNode findIndexSubOne(int index) {

        ListNode cur = head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    private ListNode searchPrev(int key) {

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

    //删除第一次出现关键字为key的节点
    public void remove(int key) {

        if (head == null) {
            return;
        }

        if (head.val == key) {
            head = head.next;
            return;
        }

/*        ListNode cur = head;
        while (cur.next != null) {
            if (cur.next.val == key) {
                break;
            }
            cur = cur.next;
        }*/

        ListNode cur = searchPrev(key);
        ListNode del = cur.next;
        cur.next = del.next;
    }

    //删除所有值为key的节点
    public void removeAllKey(int key) {
        if (this.head == null) {
            return;
        }

        ListNode cur = this.head.next;
        ListNode prev = this.head;

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

    public void clear() {
//        this.head = null;
        ListNode cur = this.head;
        ListNode curNext = null;
        while (cur != null) {
            curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        head = null;
    }
}

3. LinkedList的模拟实现

public class IndexOutOfException extends RuntimeException {

    public IndexOutOfException() {
    }

    public IndexOutOfException(String message) {
        super(message);
    }
}


public class MyLinkedList {

    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 display() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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

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

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

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

    private boolean checkIndex(int index) {
        if (index < 0 || index > size()) {
            throw new IndexOutOfException("index不合法！");
        }
        return true;
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        checkIndex(index);
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }

        ListNode node = new ListNode(data);

/*        ListNode cur = head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        node.next = cur.next;
        node.prev = cur;
        cur.next.prev = node;
        cur.next = node;*/

        ListNode cur = searchIndex(index);
        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    }

    private ListNode searchIndex(int index) {
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    // 头节点
                    head = head.next;
                    if (head != null) {
                        head.prev = null;
                    } else {
                        last = null;
                    }
                } else {
                    if (cur.next != null) {
                        // 中间节点
                        cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    } else {
                        // 尾节点
                        // cur.prev.next = cur.next;
                        cur.prev.next = null;
                        last = last.prev;
                    }
                }
                return;
            } else {
                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;
                    if (head != null) {
                        head.prev = null;
                    } else {
                        last = null;
                    }
                } else {
                    if (cur.next != null) {
                        // 中间节点
                        cur.prev.next = cur.next;
                        cur.next.prev = cur.prev;
                    } else {
                        // 尾节点
                        // cur.prev.next = cur.next;
                        cur.prev.next = null;
                        last = last.prev;
                    }
                }
                cur = cur.next;
            } else {
                cur = cur.next;
            }
        }
    }


    public void clear() {
        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.1 什么是LinkedList

LinkedList 的官方文档
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
image.png
在集合框架中，LinkedList也实现了List接口，具体如下：
image.png
【说明】:

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

4.2 LinkedList的使用

  1. LinkedList的构造
方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
public static void main(String[] args) {
    // 方法一：
    List<Integer> list1 = new LinkedList<>();
    // 方法二：
    List<Integer> list2 = new LinkedList<>();
    list2.add(1);
    list2.add(2);
    list2.add(3);
    // 方法三
    List<Integer> list3 = new LinkedList<>(list2);
}
  1. LinkedList的其他常用方法介绍
方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)截取部分 list
public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    // 1. add(elem): 表示尾插
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    System.out.println(list.size());    // 7
    System.out.println(list);   // [1, 2, 3, 4, 5, 6, 7]
    System.out.println("----------------------");

    // 2. add(index, elem): 在index位置插入元素elem
    // 在起始位置插入0
    list.add(0, 0);
    System.out.println(list);   // [0, 1, 2, 3, 4, 5, 6, 7]
    System.out.println("----------------------");

    // 3. remove(): 删除第一个元素，内部调用的是removeFirst()
    list.remove();
    System.out.println(list);   // [1, 2, 3, 4, 5, 6, 7]

    list.removeFirst(); // removeFirst(): 删除第一个元素
    System.out.println(list);   // [2, 3, 4, 5, 6, 7]

    list.removeLast();  // removeLast(): 删除最后元素
    System.out.println(list);   // [2, 3, 4, 5, 6]

    list.remove(1); // remove(index): 删除index位置的元素
    System.out.println(list);   // [2, 4, 5, 6]
    System.out.println("----------------------");

    // 4. contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
    if(!list.contains(1)){
        list.add(0, 1);
    }
    list.add(1);
    System.out.println(list);   // [1, 2, 4, 5, 6, 1]
    System.out.println("----------------------");

    // 5. indexOf(elem): 从前往后找到第一个elem的位置
    System.out.println(list.indexOf(1));    // 0
    // lastIndexOf(elem): 从后往前找第一个1的位置
    System.out.println(list.lastIndexOf(1));    // 5
    System.out.println("----------------------");

    // 6.1 get(index): 获取指定位置元素
    // 6.2 set(index, elem): 将index位置的元素设置为elem
    int elem = list.get(0);
    list.set(0, 100);
    System.out.println(list);   // [100, 2, 4, 5, 6, 1]
    System.out.println("----------------------");

    // 7. subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
    List<Integer> copy = list.subList(0, 3);
    System.out.println(list);   // [100, 2, 4, 5, 6, 1]
    System.out.println(copy);   // [100, 2, 4]
    System.out.println("----------------------");

    // 8. clear(): 将list中元素清空
    list.clear();
    System.out.println(list.size());    // 0
}
  1. LinkedList的遍历
public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1); // add(elem): 表示尾插
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    System.out.println(list.size());    // 7

    // 1. foreach遍历
    for (int e : list) {
        System.out.print(e + " ");  // 1 2 3 4 5 6 7
    }
    System.out.println();

    // 2. 使用迭代器遍历---正向遍历
    ListIterator<Integer> it = list.listIterator();
    while (it.hasNext()) {
        System.out.print(it.next() + " ");  // 1 2 3 4 5 6 7
    }
    System.out.println();

    // 3. 使用反向迭代器---反向遍历
    ListIterator<Integer> rit = list.listIterator(list.size());
    while (rit.hasPrevious()) {
        System.out.print(rit.previous() + " ");    // 7 6 5 4 3 2 1
    }
    System.out.println();
}

5. ArrayList和LinkedList的区别

不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持：O(N)
头插需要搬移元素，效率低O(N)只需修改引用的指向，时间复杂度为O(1)
插入空间不够时需要扩容没有容量的概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁
翟喜洋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】链表LinkedList
qq_61862008的博客
11-18 976
链表以及LinkedList介绍
第十六天
12-22
知识点总结 1 LinkedList特征 存储数据，非连续空间。 数据之间通过引用连接，方便遍历和使用 遍历效率较低，数据非连续空间存储，需要通过引用跳转过程来完成 删除插入操作效率高，但是注意地址的转移和保存问题。 LinkedList链表当中的操作其实大部分都是和C语言指针一个概念 2 Object类 2.1 Object类概述 Java中所有类的基类！！！ 　　 Java中所有的类都是间接或者直接继承Object类。 　　Object类的引用数据类型变量可以保存Java中任意数据类型空间的首地址。 Object类内规定了一些方法: 　　String toString(); 　　　　当
LinkedList与链表
如风暖阳的博客
07-05 451
LinkedList与链表
数据结构——循环链表
zhang_ysx的博客
01-10 2434
循环链表的简单操作
单链表，单向循环链表与双向循环链表（LinkedList）实现
MJ6666666的博客
01-17 678
动态链表 为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息（即直接后继的存储位置）我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针或链。这两部分信息组成数据元素ai的存储映像，称为结点（Node） 头结点和头指针 头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分 真实头结点：其第一个结点用于存储数据 虚拟头结点：其第一个结点不许存储数据 头指针：仅仅
【数据结构】LinkedList与双向链表
qq_61903414的博客
12-20 1528
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
c++程序链表类设计.cpp
06-30
第一行是链表元素个数n。第二行为n个元素的值。第三行为拟删除的数据位置。 【输出形式】 输出格式不固定。具体参见样例。 【样例输入1】 4 1 2 3 4 2 【样例输出1】 Origin Length：4 data：1 ...
链表实验报告1.doc
03-11
链表(linklist L),给定元素(int i) 如果链表中有给定元素(i)则返回1,否则返回0 } 8、从单链表表中查找与给定元素值相同的元素在链表中的位置 LinkedList LinkedListLocate(LinkedList L, DataType x) {//函数功能: ...
java.实现双向循环链表LinkedList
qq_60183774的博客
02-09 756
作学习记录
特殊的链表——循环链表
kxbdys的博客
04-04 2128
一、循环链表的概述 1、循环链表( Circular LinkedList)是另一种形式的链式存储结构。其特点是表中最后一个结点 的指针域指向头结点，整个链表形成一个环。 2、由此，从表中任一结点出发均可找到表中其他结点。 3、优点：从表中任意结点出发均可找到表中其他结点。 二、循环链表与单链表的区别 1、循环链表的操作和单链表基本一致。 2、差别仅在于：当遍历链表时，判别当前指针P是否指向表尾结点的终止条件不同。 3、由于循环链表中没有NULL指针，故涉及遍历操作时，其终止条件就不再像单链
JDK1.7中的LinkedList中到底是双向链表还是双向循环链表
Ysong666的博客
12-23 6367
如有错误，请大家批评指正，谢谢大家。 今天在学习数据结构时，有一个疑问，java中的LinkedList到底是双向链表还是双向循环链表，个人认为，JDK1.7里面的LinkedList没有使用双向循环链表，因为双向循环链表需要一个head结点。我们可以看一下源代码： /** * Pointer to first node. */ transient Node&l...
LinkedList学习（双向循环链表）
coach
07-11 185
[code="java"]/** * 双向循环链表测试 * @author coach * @param */ public class Node { private E element; //结点数据 private Node next; //上结点 private Node previous; //...
JDK1.7-LinkedList循环链表优化
无止于天涯 - Always on the Road
11-26 4568
最近在看jdk1.7的时候，发现了一个LinkedList的改良，baidu了一把，发现还没有人讨论这个问题。所以我自己思考了一下，在这里和大家分享，讨论一把！欢迎大家拍砖，讨论起来，把这个问题搞明白 : )                   首先，简单介绍一下LinkedList： LinkedList是List接口的双向链表实现。由于是链表结构，所以长度没有限制；而且添加/删除元素的
循环链表(Circular Linked List)
Catherine的笔记
05-03 7432
循环链表(Circular Linked List) 1. 循环链表的概念 1.1 循环链表的定义 循环链表是另一种形式的表示线性表的链表。 1.2 循环链表的结点结构 循环链表的结点包括两个部分：数据域和指针域。 (1)数据域(data)，用于存储该结点的数据元素，数据元素类型由应用问题决定。 (2)指针域(link)，用于存放一个指针，该指针指向下一个结点的开始存储地址。 循环链表的结点结构示意图：
手写LinKedList双向链表 终于搞清了什么是链表结构
qq_33471403的博客
04-27 8326
之前对Collection这块底层实现和异同点一直模糊不清，最近手动写了个链表结构实现LinKedList ，发现很多知识还是要不断去实践，专研，才能不断提升。LinKedList 实现 List接口。链表结构图   a1,a2..都代表每个Node节点。1：新建一个自定义的节点package com.kiven.linKedList; public class Node&lt;E&gt; {...
循环链表（Circual Linked List)
Sun.ME的博客
02-14 564
循环链表
循环链表与循环队列
热门推荐
雪村一郎的博客
03-07 1万+
单向循环链表 和普通的链表结构不同，单向循环链表的最后一个节点的指针指向了头结点，也就是和Head指针有相同的引用 和普通链表相比，循环链表不需要头指针，能够从任意位置实现链表遍历 双向循环链表 和单向链表相比，双向链表多了一个指向上一个节点的前向指针 相比于单向链表，双向循环链表的遍历更加灵活，但缺点是，进行插入和删除操作需要修改更多的指针
linkedlist方法
最新发布
06-10
LinkedList 是 Java 中的一个双向链表数据结构，它提供了一些常用的方法来操作链表。以下是一些常用的 LinkedList 方法： 1. add(element)：在链表的末尾添加一个元素。 2. add(index, element)：在指定位置插入一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值