LinkedList与链表

最新推荐文章于 2024-07-24 17:54:05 发布
最新推荐文章于 2024-07-24 17:54:05 发布
阅读量314 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_54077989/article/details/127578832
版权

LinkedList与链表

1.链表

1.1链表的概念

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

1.2自己实现一个链表

1.2.1单链表的实现
public class MySingleList {
    private ListNode head;

    static class ListNode {
        int value;
        ListNode next;

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

    public MySingleList(ListNode head) {
        this.head = head;
    }

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

    //展示链表
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.println(cur.value + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //从某个结点开始输出链表
    public void display(ListNode head) {
        ListNode cur = head;
        while (cur != null) {
            System.out.println(cur.value + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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

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


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

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) throws Exception {
        if (index < 0 || index > size()) {
            throw new Exception("index位置不合法");
        }
        if (index == 0) {
            addFirst(data);
        }
        if (index == size()) {
            addLast(data);
        }
        ListNode cur = findIndexSubOne(index);
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
    }

    //找出下标为index的结点
    private ListNode findIndexSubOne(int index) {
        ListNode cur = this.head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

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

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if (this.head == null) {
            return;
        }
        if (this.head.value == key) {
            this.head = this.head.next;
            return;
        }
        //找到要删除结点的前驱结点
        ListNode cur = findPrevOfKey(key);
        if (cur == null) {
            System.out.println("没有要删除的结点");
            return;
        }
        cur.next = cur.next.next;
    }

    //找出值为key的结点的前驱结点
    private ListNode findPrevOfKey(int key) {
        ListNode cur = this.head;
        while (cur.next != null) {
            if (cur.next.value == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    //删除所有值为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.value == key) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if (this.head.value == key) {
            this.head = this.head.next;
        }
    }
}
1.2.2实现双向链表
public class MyLinkedList {
    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

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

    public ListNode head;
    public ListNode tail;

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

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

    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            throw new RuntimeException("插入位置不合法");
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = FindIndexNode(index);
        ListNode node = new ListNode(data);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

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

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

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            //找到删除结点
            if (cur.val == key) {
                //如果删除结点为头结点
                if (cur == head) {
                    head = head.next;
                    if (head != null) {
                        //头结点的前驱结点为空
                        head.prev = null;
                    } else {
                        //已经到达尾巴结点了
                        tail = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }

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

    //得到单链表的长度
    public int size() {
        int count = 0;
        ListNode cur = this.head;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }
	//展示链表
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
	//清空链表
    public void clear() {
        ListNode cur = this.head;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.next = null;
            cur.prev = null;
            cur = curNext;
        }
        this.head = null;
        this.tail = null;
    }
}

2.LinkedList

2.1LinkedList的基本概念

​ LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高

2.2LinkedList的特点

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

2.2LinkedList的使用

2.1.1构造方法
方法解释
LinkedList()无参构造
public LinkedList(collection<? extends E> c)使用实现了collection的集合构造LinkedList
2.1.2常用方式
方法解释
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

2.2ArrayList和LinkedList的不同之处

  • 在存储空间上
    • ArrayList物理上一定连续
    • LinkedList逻辑上连续，物理上不一定连续
  • 随机访问
    • ArrayList支持随机访问 O(1)
    • LinkedList不支持随机访问0(N)
  • 头插
    • ArrayList需要搬移元素，效率O(N)
    • LinkedList只需修改引用的指向，效率为O(1)
  • 插入
    • ArrayList插入空间不够时需要扩容
    • LinkedList没有容量的概念
  • 应用场景
    • ArrayList应用于元素高效存储和频繁访问
    • LinkedList应用于任意位置插入和删除频繁
xuliiiiii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList:链表
07-03
本篇文章将深入探讨链表的概念、Java中的LinkedList类以及其常用方法。 ### 链表概念 链表不同于数组，它不连续存储元素。每个元素（节点）包含两部分：数据和指向下一个节点的引用。这种存储方式使得在链表中插入...
LinkedList:链表算法
04-13
链表 链表算法 链表算法的实现，该算法从stdin读取用户命令并根据用户指令命令在链表上运行特定功能，例如：PUT n，GET n，LIST，FIRST，LAST，SORT，CLEAR，REMOVE n，EXIT，其中： PUT n-将一个整数n插入到链表中...
java中LinkedList与链表
m0_62055442的博客
10-01 488
java中LinkedList与链表
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2514
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
LinkedList和链表
2301_78804510的博客
04-21 1144
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
【LinkedList与链表】
2301_81510374的博客
06-15 1154
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。【说明】：1. LinkedList实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
Java——LinkedList与链表介绍
华墨1024的博客
11-07 763
本文将对链表和LinkedList进行简要介绍
【数据结构Java版】LinkedList与链表
m0_63372226的博客
10-19 728
一、什么是LinkedList二、LinkedList的模拟实现（1）合法LinkedList的要求（2）LinkedList实现的内容1.结点个数2.链表尾插元素3.链表头插元素4.指定下标插入元素5.删除指定下标结点6.删除指定元素7.获取指定下标元素8.设置指定下标元素9.从前往后获取指定元素下标10.从后往前获取指定元素下标11.判断是否包含指定元素12.清空链表13.判断链表是否为空三、LinkedList的使用（1）LinkedList的构造四、ArrayList与LinkedList的比较
数据结构—LinkedList与链表
qq_61576108的博客
11-12 1422
链表是一种存储结构，数据元素的是通过链表中的次序实现的data表示数据；next表示指针，它总是指向自身的下一个结点，对于只有一个结点的存在，这个next指针则永远指向自身，对于一个链表的尾部结点，next永远指向开头。实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：1.2.3.LinkedList的底层是，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
linkedlist_链表_
10-02
总结来说，"linkedlist_链表_"主题深入讲解了链表的基础概念，包括单链表和双链表的创建、节点的添加与删除、链表的逆序操作以及遍历技巧。掌握这些知识对于理解和应用数据结构，尤其是处理动态数据集合，具有重要...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
c语言（7.23）
fhgfyrsg的博客
07-23 383
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 328
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 763
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 508
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
数据结构：（1）线性表
最新发布
weixin_71751116的博客
07-24 1018
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 374
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 358
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值