实现LinkedList类（数据结构之单链表）

最新推荐文章于 2024-08-27 22:35:52 发布
最新推荐文章于 2024-08-27 22:35:52 发布
阅读量95 收藏
点赞数 6
分类专栏： 拿捏数据结构 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74312445/article/details/133820651
版权

SingleLinkedList类的实现

链表是一种线性表，但是其不是通过连续的内存空间来存储数据

public class SingleLinkedList {
    static class ListNode{
        public int val;
        public  ListNode next;
        //下一个节点的地址
        public ListNode(int val) {
            this.val = val;
        }

    }
}

打印链表各节点

    public void display() {
        ListNode cur = head;
        while (cur!=null) {
            System.out.println(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;
    }

头插法和尾插法增加元素

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

    //尾插法
    public void addLast(int key) {
        ListNode node = new ListNode(key);
        ListNode cur = head;
        if(cur == null) {
            head = node;
            return;
        }
        //找到链表的尾巴  注意是cur.next 不是cur
        while (cur.next != null ){
            cur = cur.next;
        }
        cur.next = node;
    }

在指定位置插入时，需要找到指定位置index前一个节点

查询index前一个节点

    //  找到index-1的节点
    //  return index-1 的地址
    public ListNode findIndexSubOne(int index) {
        ListNode cur = head;
        while (index-1!=0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

SingleLinkedList的增加

任意位置插入

    //在指定index位置插入值为data的节点
    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 node = new ListNode(data);
        ListNode cur = findIndexSubOne(index);
        node.next = cur.next;
        cur.next = node;
    }

SingleLinkedList的删除

删除第一次出现关键字key的节点

   //删除第一次 出现关键字 为key 的节点
    public void removeOfKey(int key) {
        if(this.head == null) {
            System.out.println("此链表为空，不能进行删除！ ");
            return;
        }
        if(this.head.val == key) {
            //判断 第一个节点是不是等于要删除的节点
            this.head = this.head.next;
            return;
        }
        ListNode cur = this.head;
        while (cur.next != null) {
            if(cur.next.val != key) {
                ListNode del = cur.next;
                cur.next = del.next;
                return;
            }
            cur = cur.next;
        }
    }

删除所有值为key的结点

   // 删除所有值为 key 的节点
    public void removeAllKey(int key){
        //单独处理头节点
        if(this.head.val == key) {
            head = head.next;
        }
        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;
            }
        }

    }

链表的增加（插入）和删除时间复杂度为O (1) ,  但是找到插入（增加）和删除目标位置的时间复杂度O（N）

全部代码展示


public class SingleLinkedList {
    static class ListNode{
        public int val;
        public  ListNode next;
        //下一个节点的地址
        public ListNode(int val) {
            this.val = val;
        }

    }
    public ListNode head;
    //表示当前链表的头节点
    public void addList() {
        ListNode node1 = new ListNode(6);
        ListNode node2 = new ListNode(7);
        ListNode node3 = new ListNode(8);
        ListNode node4 = new ListNode(9);
        ListNode node5 = new ListNode(10);

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

        this.head = node1;
    }

    public void display() {
        ListNode cur = head;
        while (cur!=null) {
            System.out.println(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 key) {
        ListNode node = new ListNode(key);
        node.next = head;
        head =node;
    }

    //尾插法
    public void addLast(int key) {
        ListNode node = new ListNode(key);
        ListNode cur = head;
        if(cur == null) {
            head = node;
            return;
        }
        //找到链表的尾巴  注意是cur.next 不是cur
        while (cur.next != null ){
            cur = cur.next;
        }
        cur.next = node;
    }

    //在指定index位置插入值为data的节点
    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 node = new ListNode(data);
        ListNode cur = findIndexSubOne(index);
        node.next = cur.next;
        cur.next = node;
    }

    //  找到index-1的节点
    //  return index-1 的地址
    public ListNode findIndexSubOne(int index) {
        ListNode cur = head;
        while (index-1!=0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }


    //删除第一次 出现关键字 为key 的节点
    public void removeOfKey(int key) {
        if(this.head == null) {
            System.out.println("此链表为空，不能进行删除！ ");
            return;
        }
        if(this.head.val == key) {
            //判断 第一个节点是不是等于要删除的节点
            this.head = this.head.next;
            return;
        }
        ListNode cur = this.head;
        while (cur.next != null) {
            if(cur.next.val != key) {
                ListNode del = cur.next;
                cur.next = del.next;
                return;
            }
            cur = cur.next;
        }
    }

    // 删除所有值为 key 的节点
    public void removeAllKey(int key){
        //单独处理头节点
        if(this.head.val == key) {
            head = head.next;
        }
        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;
            }
        }

    }
    //当我们 执行 clear 这个函数的时候，会将 这个链表 当中的所有节点回收
    public void clear(){
      /*  简单粗暴的做法
        this.head = null;*/
        ListNode cur = this.head;
        ListNode curNext = null;
        while (cur != null) {
            curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        //遍历每一个节点，通过curNext保存cur.next，在将每一个节点间的联系置为空NULL；
        head = null;
    }
}

超级无敌暴龙战士(solider)
关注
  • 6
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之单链表
guankunkunwd的博客
09-26 2万+
单链表详解一、前言二、什么是链表？2.1、链表的概念：2.2、两种重要的单链表2.3、关于单链表的一些基础知识三、单链表的实现3.1、穷举法创建一个简单的链表3.2、遍历链表3.3、得到链表的长度3.4、头插法3.5、尾插法3.6、 任意位置插入节点3.7、查找是否包含关键字key是否在单链表当中3.8、删除所有节点3.9、删除第一次出现关键字为key的节点3.10、删除所有值为key的节点四、LeetCode和剑指Offer上的单链表面试题五、其他练习题 一、前言 在上篇文章中，我们详细的讲解了顺序表，
使用单向链表实现LinkedList
BiggerLee的博客
10-26 1804
单向链表是指节点中的指针域只有一个，指针域只能沿着同一个方向移动的链表。Java.util包中提供了LinkedList，此LinkedList是基于双向链表实现的。本文基于单向链表实现LinkedList中的某些方法，主要是学习使用下单向链表这种数据结构。
JavaScript 实现数据结构之单链表
Do_it
01-05 105
利用JavaScript来实现数据结构中的单链表 // 链表中需要一个Node类 来表示节点 其中的element为数据 next为指针 function Node(element) { this.element = element; this.next = null; } // linkedList类 来为插入节点，删除节点，显示列表提供方法，以及其他的辅助方法 function linkedList() { this.head = new Node("head"); ..
JAVA数据结构LinkedList(单链表)
sl1130398099的博客
03-30 347
package p02.动态链表; //这里实现的接口List已在ArrayList中体现，就不多赘述 import p01.动态数组.List; //单链表 public class LinkedList<E> implements List<E>{ private Node head; //头指针 private Node rear; //尾指针 private ...
数据结构 | 链表LinkedList(Java实现)
xxzaa的博客
04-19 494
链表（重要+困难） 对链表这种数据结构的理解 对引用和对象的理解
单链表-C++数据结构之单链表实现.zip
03-13
单链表常用于实现队列、栈、表达式解析、图形算法等多种数据结构和算法中。 总结，C++中的单链表实现涉及到对链表节点的理解、链表操作的实现以及性能优化的考虑。通过学习单链表，开发者能够更好地掌握动态数据...
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
JavaScript数据结构之单链表和循环链表
11-30
在计算机科学中，数据结构是编程的基础，而链表作为一种基础且重要的数据结构，被广泛应用于各种算法和程序设计中。链表不同于数组，它在内存中并不是连续存储的，而是通过指针链接各个元素。本文将主要讨论两种链表...
数据结构C++ 单链表的实现 .cpp和.h文件
01-21
在IT领域，数据结构是计算机科学的基础，它们是组织和管理数据的方式，使得算法能够高效地执行。单链表是一种简单但重要...在实际开发中，单链表常用于实现动态数组、队列、栈等数据结构，是软件工程师必备的技能之一。
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
数据结构——树的三种表示方法
2301_80401288的博客
08-24 1180
数据结构——树的三种表示方法 求点赞收藏关注！！！
JavaScript 数据结构 ==== 二叉树
每天都要努力学习哦~~
08-24 1006
二叉树中的节点最多只能有2个子节点，一个是左侧子节点，一个是右侧子节点，这样定义的好处是有利于我们写出更高效的插入，查找，删除节点的算法。二叉搜索树是二叉树的一种，但是它只允许你在左侧子节点存储比父节点小的值，但在右侧节点存储比父节点大的值。接下来我们将按照这个思路去实现一个二叉搜索树。
数据结构之链表
WSH2012ffff的博客
08-27 241
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
最新发布
2303_80388948的博客
08-27 613
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 460
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 1084
学习左式堆的结构
C学习（数据结构）--＞实现链式结构二叉树
weixin_47298551的博客
08-22 1031
遍历完 6 结点，再次返回 2 结点，此时 2 结点的左右孩子结点都遍历完，所以返回 1 结点，此时 1 结点的左孩子结点已经遍历完成，则遍历1 结点的右孩子结点，即 3 结点。与层序遍历类似，不同的是，取消了判断左右孩子结点是否为空结点，所以就算左右孩子结点为空值结点也会入队列，所以不完全二叉树会出现这种情况。此时4结点已经遍历完，放回 2 结点，因为 4 结点是 2 结点的左孩子结点，开始遍历 2 结点的右孩子结点，即标号为 6 的结点。标号为 2 的结点作为新的根结点，遍历 2 结点，且打印。
《数据结构（C语言版）第二版》第七章-查找（7.2-7.3.1）
qq_44883214的博客
08-25 238
一个无序序列可以通过构造一棵二叉排序树而变成一个有序序列， 构造树的过程即为对无序序列进行排序的过程。无论输入时的序列是何种顺序，CreatBST函数都会返回一个符合二叉排序树定义的正确的二叉排序树。
【数据结构入门】二叉树之堆的实现
KevinRay_0854的博客
08-20 1530
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
c语言实现数据结构单链表
06-06
好的，下面是一个使用C语言实现单链表的例子： ```c #include #include typedef struct node { int value; struct node *next; } Node; typedef struct linked_list { Node *head; } LinkedList; void add...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值