认识链表以及其常见操作Java代码实现

已于 2022-10-28 16:56:00 修改
阅读量2k 收藏 20
点赞数 17
分类专栏： 数据结构与算法（Java） 文章标签： 链表 数据结构 java
于 2021-12-19 16:15:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57105290/article/details/121169154
版权

认识链表以及其常见操作

1.链表的概念及其结构

1.1链表的概念

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

链表的每个节点都是有数据域和指针域组成。
指针域用来储存数据，指针域用来指向下一个节点。

如下图所示
在这里插入图片描述

1.2链表的结构和种类

链表主要分为三类：

  1. 带头和不带头
  2. 单向和双向
  3. 循环和非循环

这三类可以演化出8种结构：
单向：
单向带头循环
单向带头非循环
单向不带头循环
单向不带头非循环
双向：
双向带头循环
双向带头非循环
双向不带头循环
双向不带头非循环

本篇博客重点是单向不带头非循环

带头和不带头的区别：
带头：这个链表的头结点随时可能发生改变
不带头：这个链表的头结点不在发生改变

常见链表示意图：
无头单向链表
无头单链表
有头单向链表：
有头单向链表

循环单链表：
循环单链表

在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。
无头双向循环链表：
在这里插入图片描述

2.链表的实现

2.1无头单向非循环链表实现

class ListNode{
    public int val;//数据域
    public ListNode next;//null   指针域

    public ListNode(int val){
        this.val=val;
    }
}
public class MyLinkedList {
    public ListNode head;//标识单链表的头节点
    //采用穷举的方式创建链表，只是为了方便理解
   public void createList(){
       //对每一个节点进行赋值
       ListNode listNode1 = new ListNode(1);
       ListNode listNode2 = new ListNode(2);
       ListNode listNode3 = new ListNode(3);
       ListNode listNode4 = new ListNode(4);
       //将节点之间链接起来
       listNode1.next = listNode2;
       listNode2.next = listNode3;
       listNode3.next = listNode4;
       this.head = listNode1;//指明头节点
   }

2.1.1准备方法

2.1.1.1打印单链表
   //打印单链表
    public void show(){
        ListNode cur = this.head;//防止在打印的过程中导致头节点位置偏移
        while(cur!=null){//不是空节点
            System.out.println(cur.val+" ");
            cur=cur.next;//指向节点向后移动一位
        }
        System.out.println();
    }
2.1.1.2得到链表的长度
//得到链表的长度
    public int size(){
        ListNode cur = this.head;
        int count = 0;//统计链表的长度
        while(cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }
2.1.1.3查找是否包含关键自key在单链表中
//查找是否包含关键自key在单链表中
    public boolean contains(int val){
        ListNode cur = this.head;
        while(cur!=null){
            if(cur.val==val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
2.1.1.4查找具有指定值的前一个节点
//查找具有指定值的前一个节点
    public ListNode searchPrevNode(int val){
        ListNode cur = this.head;
        while(cur.next!=null){
            if(cur.next.val == val){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
2.1.1.4查找是否包含关键字key在单链表当中
//查找是否包含关键自key在单链表中
    public boolean contains(int val){
        ListNode cur = this.head;
        while(cur!=null){
            if(cur.val==val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

2.1.2头插法

    //头插法
    public void addFirst(int data){
        ListNode listNode = new ListNode(data);
        if(this.head == null){//判断是否为第一次插入
            this.head = listNode;
        }else{
            listNode.next = this.head;//先绑定后一个节点
            this.head = listNode;//更新头节点位置
        }
    }

2.1.3尾插法

//尾插法
    public void addLast(int data){
        ListNode listNode = new ListNode(data);
        if(this.head == null){//判断是否为第一次插入
            this.head = listNode;
        }else{
            ListNode cur = this.head;//防止头节点位置偏移
            while(cur.next!=null){
                cur = cur.next;//找到尾节点
            }
            cur.next = listNode;//链接节点
        }
    }

2.1.4任意位置插入，假设第一个数据节点为0下标

 //任意位置插入，第一个数据节点为0号下标
    public void addIndex(int index,int data){
        if(index < 0 || index > size()){//首先判断坐标是否合法
            System.out.println("下标不合法");
            return;
        }
        //若插入位置为第一个位置，头插法
        if(index == 0){
            addFirst(data);
            return;
        }
        //若插入位置为最后一个位置，尾插法
        if(index == size()){
            addLast(data);
            return;
        }
        ListNode cur = searchPrev(index);//找到指定的坐标位置
        ListNode listNode = new ListNode(data);
        //插入节点
        listNode.next = cur.next;
        cur.next = listNode;
    }

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

删除某一个节点的原理就是不再有引用指向该节点，Java虚拟机会自动回收

    //删除第一次出现关键字key的节点
    public void remove(int val){
        if(this.head ==null) return;//没有节点直接返回
        //单独判断头节点的问题
        if(this.head.val == val){
            this.head = this.head.next;
            return;
        }
        ListNode cur = searchPrevNode(val);//查找到指定值的坐标位置的前一个节点
        if(cur ==null){//判断坐标是否为空
            System.out.println("没有你要删除的节点");
            return;
        }//删除该节点
        ListNode del = cur.next;
        cur.next = del.next;
    }

2.1.6删除所有值为key的节点

 //删除所有值为key的节点
    public void removeAllKey(int val){
        if(this.head == null){//若没有节点，直接返回
            return;
        }
        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while(cur!=null){//节点不为空，进入循环
            if(cur.val == val){//找到一个与指定值相同的节点，删除
                prev.next = cur.next;
                cur = cur.next;//删除后向后移动一位
            }else{//与指定值不同，向后移动一位
                prev = cur;
                cur = cur.next;
            }
        }
        //最后判断头节点是否为该值
        if(this.head.val == val){
            this.head = this.head.next;

        }
    }

2.1.7清空链表

//清空链表
public void clare(){
    while(this.head!=null){
        ListNode curNext = this.head.next;
        this.head = null;
        this.head = curNext;
    }
    return;
}

2.2无头双向链表实现

class ListNodeD{
    public int data;//数据域
    public ListNodeD prev;//前驱
    public ListNodeD next;//后继

    public ListNodeD(int data){
        this.data = data;
    }
}

public class MyRealLinkedList {
    public ListNodeD head;//头
    public ListNodeD last;//尾

    public MyRealLinkedList(){
        //this.head = new ListNode(-1);傀儡节点
    }

2.2.1准备方法

2.2.1.1查找节点
    //查找节点
    public ListNodeD findIndex(int index){
        ListNodeD cur = this.head;
        while(index != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }
2.2.1.2得到链表的长度
    //得到链表的长度
    public int size(){
        int count = 0;
        if(this.head == null) return count;//链表长度为零
        ListNodeD cur = this.head;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }

2.2.1.3查找是否包含关键字key在单链表当中

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

2.2.1头插法

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

2.2.2尾插法

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

        }
    }

2.2.3任意位置插入，假设第一个数据节点为0下标

   //任意位置插入，第一个节点为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;
        }
        ListNodeD cur = findIndex(index);
        ListNodeD node = new ListNodeD(data);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur;
        cur.prev = node;
    }

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

   //删除第一次出现key的节点
    public void remove(int key){
        ListNodeD cur = this.head;
        while(cur!=null){
            if(cur.data == key){
                //判断是不是头节点
                if(cur == this.head){
                    this.head = this.head.next;
                    if(this.head == null){//防止只有一个节点
                        this.last = null;
                    }else{
                        this.head.prev = null;
                    }
                }else{
                    cur.prev.next = cur.next;
                    //尾巴节点
                    if(cur.next == null){
                        this.last = cur.prev;
                    }else{
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }else{
                cur = cur.next;
            }
        }
    }

2.2.5删除所有值为key的节点

    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNodeD cur = this.head;
        while(cur!=null){
            if(cur.data == key){
                //判断是不是头节点
                if(cur == this.head){
                    this.head = this.head.next;
                    if(this.head == null){//防止只有1个节点
                        this.last = null;
                    }else{
                        this.head.prev = null;
                    }
                }else{
                    cur.prev.next = cur.next;
                    //尾巴节点
                    if(cur.next == null){
                        this.last = cur.prev;
                    }else{
                        cur.next.prev = cur.prev;
                    }
                }
                cur = cur.next;//继续往后走，直到null的时候
            }else{
                cur = cur.next;
            }
        }
    }

2.2.6清空链表

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

}

单链表结构与顺序存储结构的优缺点

存储分配方式：

  • 顺序存储结构用一段连续存储单元依次存储线性表数据元素
  • 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素

时间性能：

  • 查找
    顺序存储结构O(1)
    单链表O(n)
  • 插入和删除
    顺序存储结构需要平移移动表一半的元素，时间复杂度为O(n)
    单链表在找出位置的指针后插入和删除的复杂度仅为O(1)

空间性能：

  • 顺序存储结构需要与分配存储空间，分大了浪费，分小了易发生溢出
  • 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制

结论：

  1. 若线性表需要频繁的查找，很少进行插入和删除操作，宜采用顺序存储结构
  2. 当线性表中元素个数变化较大或者根本不知道有多大时，最好采用单链表结构
YOLO~~~
关注
专栏目录
双链表V3.0（含迭代器，Java语言描述）
12-22
经过了双链表V1.0的根据接口编写成型、双链表V2.0的功能大幅度增强，这里推出了双链表V3.0，功能的丰富性不及V2.0，但加入了迭代器，代码的编写也更加的合理了，应该说是比较好的作品了。 不过还是推荐看看java.util...
[Java]实现单链表及其基本操作
sjhdaj的博客
03-20 870
带头结点的单链表第一个结点作为头结点，并在其下半部分存放第一个结点的地址，之后的每个结点都会在上半部分存放元素值，在下半部分存放下一个结点的地址。如果我们要在一个单链表表头插入一个结点，我们需要先让此结点成为一个新的头结点，并让该新头结点的地址域存放原来第一个结点的地址。如果我们要删除的结点是第一个结点，则直接使头结点连接第二个结点即可，如果是删除其他的结点，则需要找到该结点的前驱结点在进行删除。如果我们要在单链表的尾部插入一个元素，只要将原来单链表尾部的元素地址域指向下一个结点的地址即可。
Java~单链表基本操作图文详解_清晰易懂（超详细，含完整代码）
Zebra的博客
10-28 3386
一.单链表的定义 1.结点的定义
单链表各种基本运算的算法
Hey3399的博客
04-23 3994
初始化单链表 /初始化单链表 void InitList(LinkNode *&L) { //创建头结点 L=(LinkNode*)malloc(sizeof(LinkNode)); L->next=NULL; } 头插法建立单链表 //头插法建立单链表 void CreateListF(LinkNode *&L,ElemType a[],int n) { //创建头结点 LinkNode *s; L=(LinkNode*)malloc(sizeof(LinkNo
Java输入建立链表
qq_46479446的博客
02-08 430
【代码】Java输入建立链表。
单链表的基本操作《Java代码实现》
kitiyang的博客
03-02 698
项目场景： 提示：这里简述项目相关背景： 例如：项目场景：示例:通过蓝牙芯片(HC-05)与手机 APP 通信，每隔 5s 传输一批传感器数据(不是很大) 问题描述： 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override public void run() { bytes = mmInStream.read(buffer); mHandler.obta
BigInteger:Java项目-使用链表数据结构执行数学运算
04-27
本项目的目标是实现一个基于链表数据结构的大整数操作，这将有助于理解大整数的内部工作原理以及如何高效地执行数学运算。 首先，我们需要了解链表数据结构。链表是一种非连续存储的数据结构，每个节点包含数据和...
java代码-《算法》练习1.1.6
07-15
1. **数据结构**：基础的数据结构如数组、链表、栈或队列可能会被使用，来存储和操作数据。 2. **排序与搜索**：基础的排序算法（如冒泡排序、选择排序、插入排序、快速排序或归并排序）或搜索算法（如线性搜索、二...
JAVA贪吃蛇游戏毕业设计(源代码+论文).rar
最新发布
04-05
Java贪吃蛇游戏是一款经典的基于Java编程语言实现的桌面游戏，是许多计算机科学与技术专业学生在毕业设计中常见的选题。本项目包含了完整的源代码和相关论文，为学习者提供了一个深入理解Java编程和游戏开发的实例。...
Java开发之京东客服机器人
07-28
通过这个项目，你将不仅能够学习到Java和JavaScript的基本语法，还能接触到实际项目开发中的许多常见技术，这对于提升你的编程技能和项目经验非常有帮助。在实践中学习，结合源码的阅读和注释的理解，将使你对编程有...
Java文件输入输出流实现链表操作
m0_73814009的博客
10-30 150
通常，它用于处理包含多个值的字符串，例如从文件或用户输入中读取的一行文本，其中各个值之间用特定的分隔符（通常是空格或逗号）分隔。【输出文件】将操作后链表结点值输出到文件dlist.out，如果链表为空，输出－1。【问题描述】输入N(3<=N<=10)个数，依次将这些数插入到结构为。再输入一个数num，从链表中删除值为num的结点。第一行是一个数字n(<=n<=10)，代表双链表的结点数。第二行是n个数字，代表各结点的数值，中间以空格间隔。第三行是一个数字，代表将要删除的结点的数值。
《Java数据结构基础》单链表的手动实现
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-30 1234
详细你对单链表肯定是不陌生的吧！但你知道单链表是怎么实现的吗？单链表是怎样通过链式结构构建起来的呢？一起来看看吧！！！
java中输入与输出的方法总结怎么写
fmz2222的博客
03-17 874
控制台输出方法，第一个输出方法：System.out.print()，第二个输出方法：System.out.println()，第三个输出方法：System.out.printf()system . out . println(b)；//println()换行输出b的值。//print()输出b的值，不换行。System.out.printf('账号：%s '，名称)；
JAVA链表基础——代码随想录 链表
weixin_44023809的博客
11-28 414
本文档创作于代码随想录算法训练营四期。
Java实现单链表（步骤详解+源码）
GSCY
10-14 7671
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
数据结构-链表的基本操作（java）
qq_62928039的博客
03-10 642
如果是“show”则输出列表中的所有元素，如果列表是空的，则输出“Link list is empty”。每行有一个字符串，字符串是“get”，“insert”，“delete”，“show”中的一种。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。这一行整数是用来初始化列表的，并且输入的顺序与列表中的顺序相反，也就是说如果列表中是1、2、3那么输入的顺序是3、2、1。图1：链表类型的定义以及获得链表元素的算法描述。（作者：煮酒话桑麻）
Java实现单链表的创建与输出
qq_54876618的博客
09-07 1046
本人学习Java第一天，实现利用Java从键盘中输入数据创建带头结点的单链表，并且输出这个单链表。
链表简单的输入输出
qq1183242924的博客
09-26 9409
用单向链表实现简单的输入输出，函数可以拿去用。 #include <stdio.h> #include <stdlib.h> /*链表结点结构体*/ struct NODE { int m; //可根据需求修改数据域。 struct NODE *next; } ; /*函数声明*/ struct NODE *creat(); void output(struct NODE *head); int main() { struct NODE *he
算法题——链表中的节点每k个一组翻转
bm1998
04-27 784
1. 本题知识点 链表 2. 题目描述 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 进阶： 你可以设计一个只使用常数额外空间的算法来解决此问题吗？ 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。 输入：head = [1,2,3,4,5], k = 2 输出：[2,1,4,3,5] 输入：head = [1,2,3,4,5], k = 3 输出：[3
Java实现栈结构的源代码教程
- 在实际的Java代码编写中，合理的注释是必不可少的，它有助于其他开发者（或未来的自己）理解代码的设计和逻辑。教程中的源代码可能包含详尽的注释来说明每个步骤和方法的作用。 10. 面向对象编程的高级特性 - ...
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值