MyLinkedList--自己实现单链表

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量67 收藏
点赞数
文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f7ashion/article/details/132966171
版权

目录

1.创建节点类 

2.创建链表 

3.链表的长度

4.链表是否包含关键字key 

5.在链表的任意的位置插入节点 

6.删除第一次出现值为key的节点 

 7.删除所有值为key的节点

8.清空所有链表 

9.综合代码 

1.创建节点类 

  • val--链表节点存放的数据,这里我们使用int数据类型.
  • next--存放下一个节点的地址
class ListNode{
    public int val;
    public ListNode next;
 
    //构造函数
    public ListNode(int =num){
        this.val = num;
    }

2.创建链表 

方法一：枚举法 

public class MyLinkedList {
    public ListNode head;//链表的头
 
    public void creatList(){
        ListNode listNode1 = new ListNode(1);
        ListNode listNode2 = new ListNode(2);
        ListNode listNode3 = new ListNode(3);
        ListNode listNode4 = new ListNode(4);
        ListNode listNode5 = new ListNode(5);
 
        this.head = listNode1;
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
    }

 方法二：头插法public void addFirst(int data)

 链表的头节点的位置插入一个新节点,新节点的next指向head,并让head指向next.


public class MyLinkedList {
    public ListNode head;//链表的头
 
   public void addFirst(int data){
        ListNode node = new ListNode(data);
        node.next = this.head;
        this.head = node;
    }
}

方法三：尾插法public void addLast(int data)

尾节点的位置插入一个新节点,先遍历链表找到尾部的节点,让尾部的节点的next指向新节点. 

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

3.链表的长度

定义一个int类型变量count来计数,遍历链表,有一个节点,count就++. 最后返回count.

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

4.链表是否包含关键字key 

遍历链表,比较节点与key的值是否相等. 相等就返回true,不相等就返回false.

    public boolean contains(int key){
        ListNode cur = this.head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

5.在链表的任意的位置插入节点 

当位置==0的时候就是头插法(之前写过的,在标签2.创建链表),位置==长度就是尾插法(之前也写过),我们不用再写一遍,直接调用之前的,

public void addIndex(int index,int data){
        if(index < 0 ||index > Size()){   //对index位置的合法性进行判断
            return;
        }
        if(index == 0){          //相当于头插法
            addFirst(data);
            return;
        }
        if(index = Size()){      //相当于尾插法
            addLast(data);
            return;
        }
       ListNode cur = head.next;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }//找到index位置前一位置的地址
        ListNode node = new ListNode(data);
        node.next = cur.next;
        cur.next = node;
}

6.删除第一次出现值为key的节点 

 如果删除的是头节点,那就让头节点=头节点的next,如果不是,那就需要找到删除节点的前一个节点,

让它的next等于删除节点的next,这样就删除next了.

 //找到key的前驱（前一节点）
    public ListNode findPre(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 remove(int key){
        if(this.head == null){
            return;
        }
        if(this.head.val == key){
            this.head = this.head.next;
            return;
        }
        ListNode cur = findPre(key);
        if(cur == null){
            return;             //没有要删除的节点
        }
        ListNode del = cur.next;//定义要删除的节点
        cur.next = del.next;
}

 7.删除所有值为key的节点

 使用双指针,pre是cur的前指针,cur用来判断是否等于key,等于那就让pre.next=cur.next,删掉cur指向的节点,然后继续往下走直到末尾.

    public ListNode removeAllKey(int key){
        if(this.head = null){
            return null;
        }
        //方便删除头节点
        ListNode dummyNode=new ListNode(-1);
        dummyNode.next=this.head;
        ListNode prev = dummyNode;
        ListNode cur = this.head;
        while(cur != null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        return dummyNode.next;
    }

8.清空所有链表 

头节点指向null

    public void clear(){
        this.head=null;
        }
    }

9.综合代码 

import java.util.List;
 
 
//ListNode代表一个节点
class ListNode{
    public int val;
    public ListNode next;
 
    //构造函数
    public ListNode(int num){
        this.val = num;
    }
}
public class MyLinkedList {
 
    public ListNode head;//链表的头
 

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = this.head;
        this.head = node;
    }
 
    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
        } else {
            ListNode cur = this.head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }
 
 
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
 
    //得到单链表的长度
    public int size() {
        int count = 0;
        ListNode cur = this.head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
 
 
 
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        if (index < 0 || index > Size()) {
            return;
        }
        if (index == 0) {          //相当于头插法
            addFirst(data);
            return;
        }
        if (index == Size()) {      //相当于尾插法
            addLast(data);
            return;
        }
        ListNode cur = head.next;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }//找到index位置前一位置的地址
        ListNode node = new ListNode(data);//初始化node
        node.next = cur.next;
        cur.next = node;
    }
 
    //找到key的前驱（前一节点）
    public ListNode fingPre(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 remove(int key) {
        if (this.head == null) {
            return;
        }
        if (this.head.val == key) {
            this.head = this.head.next;
            return;
        }
        ListNode cur = findPre(key);
        if (cur == null) {
            return;             //没有要删除的节点
        }
        ListNode del = cur.next;//定义要删除的节点
        cur.next = del.next;
    }
 
    //删除所有值为key的节点
    public ListNode removeAllKey(int key) {
        if (this.head = null) {
            return null;
        }
        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 (this.head.val == key) {
            this.head = this.head.next;
        }
        return this.head;
    }
 
    //清空链表
    public void clear() {
        
       this.head=null;
    }
}

 

AZHOUN
关注
「数据结构」- 单链表
「zero」的博客
05-21 914
链表概念单链表单链表结构功能实现头插法尾插法判断单链表中是否包含关键字key单链表长度任意位置插入节点删除节点删除重复节点打印单链表释放内存总结 链表概念 链表也是属于线性表的一种，是一种物理(内存)存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头 循环、非循环 单链表 虽然有这么多的.
MyLinkedList-单链表
weixin_45683800的博客
03-25 136
实现功能: 头插法,尾插法,查找元素,任意位置插入,删除某一个,删除所有出现key的节点,clear()…等功能 实现代码:
数据结构-链表-单链表
张文军
08-01 209
单链表 文章目录单链表创建Node节点 创建Node节点 //Node节点类 package com.njau.link; /** * 链表结点的实体类 * @author 张文军 * */ public class Node { Node next = null;//下一个结点 int data;//结点数据 public Node(int data){ ...
力扣 -设计链表 --单链表的实现
q_a_z_w_s_x___的博客
01-24 217
题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为
数据结构 --java实现单链表
提莫大魔王的博客
04-10 196
1) 链表是以节点的方式来存储, 是链式存储 2) 每个节点包含 data 域， next 域：指向下一个节点. 3) 链表的各个节点不一定是连续存储. 4) 链表分 带头节点的链表和 没有头节点的链表，根据实际的需求来确定 代码实现 package com.testlist; /** * 数据结构-链表的实现 */ public class LinkedListDemo { ...
Java数据结构-单链表
m0_60760920的博客
10-08 186
顺序表的优缺点:优点:😔 连续的物理空间,支持根据下标随机访问缺点:😔插入数据,空间不足时要扩容,会造成一定的资源浪费😔头插或中间位置插入元素时需要挪动元素,效率比较低基于顺序表的缺点,就出现了链表.
数据结构---单链表和双向链表----Java实现单链表及双向链表的创建与增删查改等9种操作(含详细源代码与注释)
cheng
05-21 619
单链表与双向链表单链表双向链表 概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头 循环、非循环 尽管以上情况组合起来非常之多，但是我们主要讨论的是两种： 1、无头单向非循环链表 2、无头双向非循环链表 单链表 单链表的实现主要有如下9种方法 public void addFirst(int data) 参数：插入数据data。功能：头插法插入data p
Leetcode---单链表
Glon_xue的博客
08-16 457
单链表 本博客的题均为leetcode上的摘录，都是我的刷题答案，仅做参考，若有错误，欢迎指正 前面提到的数组和字符串跟我们这里要说的链表都属于数据结构里面的线性表； 所谓线性表，就是在内存中存储的数据元素都是连续的，一一对应的，也可以理解成是一串一串的。计算机通常将线性表的数据按照前后顺序将他们连接在一起，方便程序遍历和操作。 线性表又分为顺序存储结构和链式存储结构： ...
线性表的链式存储---单链表
cherry的博客
05-16 227
单链表 单链表：n个结点链接成一个链表，就是线性表的链式存储，因为此链表的每个结点只包含一个指针域，所以叫做单链表。 结点由存储数据元素的数据域和存储指针的指针域组成 我们把单链表的第一个结点叫做头指针，之后的每一个结点就是上一个结点的后继结点指向的位置。为了方便表示，一般在第一个结点之前设置一个结点，称为头结点，头结点的数据域可以不存储任何信息，也可以存储线性表的长度等附加信息，指针域指向第...
java实现单链表增删改查的实例代码详解
10-16
接下来，我们详细探讨如何在Java中实现单链表的增加、删除、修改和查询操作。 首先，定义一个节点类Node，它是一个泛型类，表示单链表中的每个节点，包含两个属性：一个是数据域e，用来存储节点数据；另一个是指针...
算法笔记--简单实现单链表的增删功能
dosthing的博客
03-14 604
算法笔记–简单实现单链表的增删功能 链表也是一种线性的数据结构，节点与节点通过指针相连，从指针角度来看，链表可以分为单向链表、双向链表、循环链表。单向链表如图所示： 解题：Java没有指针，使用对象引用实现 定义一个头结点，链表长度计数器 链表的插入：将尾结点的指向改为当前插入的节点 链表的删除：找到删除节点，并将删除节点的前节点指向下一节点 链表的有点： 增删节点十分方便 案例实践 public class SimpleListDemo { public static void mai
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 667
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 614
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 468
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 704
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 299
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1094
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
C#实现基础链表类MyLinkedList详解
"C#实现的简单链表类实例，包含结点类Node和链表类MyLinkedList，用于创建和操作单链表" 在C#编程语言中，链表是一种非常基础的数据结构，用于存储一系列有序的数据元素。尽管C#标准库提供了`System.Collections....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值