单链表总结_用Java

最新推荐文章于 2022-02-03 22:30:45 发布
最新推荐文章于 2022-02-03 22:30:45 发布
阅读量240 收藏 1
点赞数 3
分类专栏： 笔记 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58430482/article/details/121087032
版权

目录

单链表的增添

头插入法

尾插入法

根据指定下标插入节点

单链表的删除

根据下标删除结点

删除该单链表中所有值与传入数据相同的节点

所有的代码放在下面

进一步理解单链表

    最近刚刚学完单链表，想趁热打铁总结一下。
    首先，单链表的每个结点在内存中的存储相互是没有联系的，每个结点是靠着结点内存储的结点类型的引用'next'找到下一个结点的，所以可以形成一个单链表。
    我们要明确的是，单链表之所以可以成为链表，是因为它的'next'。
    想象一下，你在一张白纸上随机画出了若干个点，这些点在白纸上随机分布，每个点只有一条线可以连接下一个点，当然，这条线也可以什么也不连接(连接null)，并且，这条线是单向的，无法逆行，即若沿着该线从A点走到B点，无法原路返回。
    好了，现在单链表的框架已经有了，让我们把这些思想抽象为代码吧:

class Node{
    //该类就是抽象出来的单链表的躯体

    public int data;//这个结点里面存放的数据
    public Node next;//可以存储Node类型地址的引用，相当于上述的绳子

    Node(){}
    Node(int data){
        this.data=data;
    }
    Node(Node next){
        this.next=next;
    }
    Node(int data,Node next){
        this.data=data;
        this.next=next;
    }
}


public class Test {
    //主类，我们对单链表的操作全部在该类中完成

    public static Node head;//存储单链表的头结点
    public static int size;//为了方便期间，我们增加一个size属性表示单链表的有效元素
}

下面，我将编写单链表的增加与删除两个方面

单链表的增添

单链表的增添主要分为头插入法，尾插入法，与根据指定下标插入法

头插入法

头插入法，顾名思义就是每次将结点从表头插入，注意每次插入要改变head，代码如下:

   public static void headAdd(int data){
        //该方法是单链表的头插入法，传入要插入的数据，可以将其按头插入法插入单链表中
        //由于该方法是定义在主类中，而主类就是单链表的类，故无需返回值，也无需将head传入该方法中
        if(head==null){//表示该单链表没有元素
            Node node=new Node(data,null);
            size++;
            head=node;
            return ;
        }
        Node node=new Node(data);
        //下面两行代码是头插法的核心思想，可以画图体验一下
        node.next=head;
        head=node;
        size++;
    }

尾插入法

也好理解，就是在单链表的最后一个元素后插入元素，代码如下:


    public static void footAdd(int data){
        //传入一个数据data，新建一个结点将数据存入，并将该结点存储在单链表的尾部

        //尾插的关键在于找到最后一个结点
        //这里不能直接用head,不然该方法走完后链表就丢了,没有head就无法访问链表
        Node copyHead=head;
        while(copyHead.next!=null){
            copyHead=copyHead.next;
        }
        Node node=new Node(data);
        copyHead.next=node;
        node.next=null;
        size++;
    }

根据指定下标插入节点

要在指定位置插入节点，核心思想是要找到改位置节点的前驱，并将节点插入，代码如下:

    public static void indexAdd(int index,int data){
        //先判断index的合法性
        //index==0代表头插入，index==size代表尾插入
        if(index<0||index>size){
            System.err.println("输入下标有误!!");
            return;
        }
        if(index==0){
            headAdd(data);
            return;
        }
        if(index==size){
            footAdd(data);
            return;
        }
        Node copyHead=head;
        while(index-1!=0){//由于要找前驱，故为index-1(少找一位)
            copyHead=copyHead.next;
            index--;
        }
        //这两行代码是关键
        Node node=new Node(data,copyHead.next);
        copyHead.next=node;
        size++;
    }

单链表的删除

单链表的删除我主要会写根据下标删除与删除单链表中所有与输入数据相同的数据

根据下标删除结点

很简单也很基础的单链表操作，代码如下:

    public static void indexDelete(int index){
        //核心是找到该下标的前驱
        if(index<0||index>size-1){//注意这里是size-1
            System.err.println("输入下标有误!!");
            return ;
        }
        if(index==0){
            head=head.next;
            size--;
            return ;
        }else{
            Node copyHead=head;
            //找前驱
            while(index-1!=0){
                copyHead=copyHead.next;
                index--;
            }
            copyHead.next=copyHead.next.next;
            size--;
        }
    }

删除该单链表中所有值与传入数据相同的节点

该删除的难点在于连续删除节点，我分别将创建虚拟头结点与不创建虚拟头结点的代码都编写一，代码如下:

        //不创建虚拟头结点删除
    public static void deleteAll1(int data){
        //若头部就是要删除的结点，此时除了删除，还要修改head
        while(head!=null&&head.data==data){
            head=head.next;
            size--;
        }
        if(head==null){
            return ;
        }else{
            //此时删除不需要改变头，并且头部也不是要删除的结点，故可以从copyHead.next处开始判断，而且这样写便于删除
            Node copyHead=head;

            //下面的是难点
            while(copyHead.next!=null){
                if(copyHead.next!=null&&copyHead.next.data==data){
                    copyHead.next=copyHead.next.next;
                    size--;
                }else if(copyHead.next!=null){
                    copyHead=copyHead.next;
                }else{
                    break;
                }
            }
        }
    }

    //创建虚拟头结点删除
    public static void deleteAll2(int data){
        Node dyHead=new Node(head);//注意，我们要创建的是结点,不是引用
        Node copyHead=dyHead;
        while(copyHead.next!=null){
            if(copyHead.next!=null&&copyHead.next.data==data){
                copyHead.next=copyHead.next.next;
                size--;
            }else if(copyHead.next!=null){
                copyHead=copyHead.next;
            }else{
                break;
            }
        }
        head=dyHead.next;
    }

可以看出来，创建虚拟头结点比较方便

当你掌握了上面这些代码后，你就差不多有了初步操作单链表的能力了(单链表的简单查找与修改可以自己编写练练)，对了，这里吧单链表的打印也一并给你们，方便查看链表

 public static String print(){
        Node copyHead=head;
        String ret="";
        while(copyHead!=null){
            ret+=copyHead.data+"->";
            copyHead=copyHead.next;
        }
        ret+="null";
        return ret;
    }

所有的代码放在下面

class Node{
    //该类就是抽象出来的单链表的躯体

    public int data;//这个结点里面存放的数据
    public Node next;//可以存储Node类型地址的引用，相当于上述的绳子

    Node(){}
    Node(int data){
        this.data=data;
    }
    Node(Node next){
        this.next=next;
    }
    Node(int data,Node next){
        this.data=data;
        this.next=next;
    }
}

public class Test {
    //主类，我们对单链表的操作全部在该类中完成
    public static Node head;//存储单链表的头结点
    public static int size;//为了方便期间，我们增加一个size属性表示单链表的有效元素



    public static void headAdd(int data){
        //该方法是单链表的头插入法，传入要插入的数据，可以将其按头插入法插入单链表中
        //由于该方法是定义在主类中，而主类就是单链表的类，故无需返回值，也无需将head传入该方法中
        if(head==null){//表示该单链表没有元素
            Node node=new Node(data,null);
            size++;
            head=node;
            return ;
        }
        Node node=new Node(data);
        //下面两行代码是头插法的核心思想，可以画图体验一下
        node.next=head;
        head=node;
        size++;
    }

    public static void footAdd(int data){
        //传入一个数据data，新建一个结点将数据存入，并将该结点存储在单链表的尾部

        //尾插的关键在于找到最后一个结点
        //这里不能直接用head,不然该方法走完后链表就丢了,没有head就无法访问链表
        Node copyHead=head;
        while(copyHead.next!=null){
            copyHead=copyHead.next;
        }
        Node node=new Node(data);
        copyHead.next=node;
        node.next=null;
        size++;
    }

    public static void indexAdd(int index,int data){
        //先判断index的合法性
        //index==0代表头插入，index==size代表尾插入
        if(index<0||index>size){
            System.err.println("输入下标有误!!");
            return;
        }
        if(index==0){
            headAdd(data);
            return;
        }
        if(index==size){
            footAdd(data);
            return;
        }
        Node copyHead=head;
        while(index-1!=0){//由于要找前驱，故为index-1(少找一位)
            copyHead=copyHead.next;
            index--;
        }
        //这两行代码是关键
        Node node=new Node(data,copyHead.next);
        copyHead.next=node;
        size++;
    }



    public static void indexDelete(int index){
        //核心是找到该下标的前驱
        if(index<0||index>size-1){//注意这里是size-1
            System.err.println("输入下标有误!!");
            return ;
        }
        if(index==0){
            head=head.next;
            size--;
            return ;
        }else{
            Node copyHead=head;
            //找前驱
            while(index-1!=0){
                copyHead=copyHead.next;
                index--;
            }
            copyHead.next=copyHead.next.next;
            size--;
        }
    }

    //不创建虚拟头结点删除
    public static void deleteAll1(int data){
        //若头部就是要删除的结点，此时除了删除，还要修改head
        while(head!=null&&head.data==data){
            head=head.next;
            size--;
        }
        if(head==null){
            return ;
        }else{
            //此时删除不需要改变头，并且头部也不是要删除的结点，故可以从copyHead.next处开始判断，而且这样写便于删除
            Node copyHead=head;

            //下面的是难点
            while(copyHead.next!=null){
                if(copyHead.next!=null&&copyHead.next.data==data){
                    copyHead.next=copyHead.next.next;
                    size--;
                }else if(copyHead.next!=null){
                    copyHead=copyHead.next;
                }else{
                    break;
                }
            }
        }
    }

    //创建虚拟头结点删除
    public static void deleteAll2(int data){
        Node dyHead=new Node(head);//注意，我们要创建的是结点,不是引用
        Node copyHead=dyHead;
        while(copyHead.next!=null){
            if(copyHead.next!=null&&copyHead.next.data==data){
                copyHead.next=copyHead.next.next;
                size--;
            }else if(copyHead.next!=null){
                copyHead=copyHead.next;
            }else{
                break;
            }
        }
        head=dyHead.next;
    }

    public static String print(){
        Node copyHead=head;
        String ret="";
        while(copyHead!=null){
            ret+=copyHead.data+"->";
            copyHead=copyHead.next;
        }
        ret+="null";
        return ret;
    }



    public static void main(String[] args) {
        headAdd(1);
        headAdd(2);
        headAdd(2);
        footAdd(2);
        footAdd(2);
        footAdd(2);

        System.out.println(print());
        deleteAll1(2);
        System.out.println(print());
    }

}

进一步理解单链表

记住我开头所举的例子，单链表之所以是单链表，本质上是因为next

做完下面这道题相信你的理解会更深入，答案我粘在下面

面试题 02.04. 分割链表 - 力扣（LeetCode） (leetcode-cn.com)

    public ListNode partition(ListNode head, int x) {
        //创建两个虚拟头结点，便于拆分链表
         ListNode smallHead=new ListNode(-1);
         ListNode bigHead=new ListNode(-1);
         //创建两个指针，用于操纵新创建的链表
         ListNode bigTial=bigHead;
         ListNode smallTiai=smallHead;
         //遍历原链表
         while(head!=null){
             //该值比给定值小
             if(head.val<x){
                 //插入small
                 smallTiai.next=head;
                 smallTiai=head;
             }else{
                 //比给定值大或等于
                 //插入big
                 bigTial.next=head;
                 bigTial=head;
             }
             head=head.next;
         }
         //清理该链表尾部
         bigTial.next=null;
         //small无需清理，直接链接
         smallTiai.next=bigHead.next;
         return smallHead.next;
    }
m0_58430482
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
1.实验目的及要求 1.1实验目的： （1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现；...（1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、删除、查找等基本操作。
单链表知识总结
papillonlong的博客
01-13 195
使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作。单链表(带头结点) 逻辑结构示意图如下。
单链表知识点总结
weixin_47651920的博客
10-27 1847
一.什么是链表 1.概念 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 逻辑上连续是我们想象的连续，并不是真正的连续。 2.链表的分类 单向双向，带头结点不带头结点，循环非循环，组合起来共有8种 二.单链表及单链表的实现 这里我们只实现单链表中的增删改查和其他一些基本的方法，如果单链表弄清了，其他来链表只不过是单链表的延伸。 1.单链表的结构示意图 这里以值域为整形为例，在实际中，值域可以为任意类型 2.图解结点的增删改查 （1）插.
【链表】单链表知识总结-内含代码操作及其说明
qq_53830608的博客
01-06 1874
认识链表： 顺序表：逻辑相邻，物理也相邻（例如数组，坐在旁边的一定是舍友） 链表：逻辑相邻，物理不一定相邻（坐在旁边的也不一定是舍友）//不能从第一个数一直遍历到最后一个数 链表就是线性表的链式表述。 因此，链表结点的意义：存放数据+下一个结点的地址 ①结点定义代码如下： typedefintElemType; typedefstructNode { ElemTypedata;//存放数据 structNode* next;// 存放...
C链表总结——单链表
物联黄同学的博客
06-25 617
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 最近学了一下关于单链表的知识以及做了一些链表有关的习题，接下来做一下单链表的总结，所用语言为C 一、什么是单链表 如上图，这就是一个简单的单链表示意图。（ppt制作有点烂哈） 首先，在回答什么是单链表前，先简单谈谈什么是链表。链表就是一种数据结构，而之前学到的数组也是一种数据，链表和数组算是两种最简单
单链表的基本操作（学习总结）
m0_61395860的博客
02-03 3781
单链表的声明初始化： 1.头文件： 这里不做太多说明，是学习C语言的基础。 #include<stdio.h> #include<stdlib.h> 2.结构声明： 数据结构算法中，每个表，树，图类的工具组都需要定义它的结构来符合我们的需求。 例如本次的单链表： 这里的 Lnode和*Linklist(指针型)是结构体的不同表达方式，二者都可任意使用，例如：Lnode *H=Linklist H typedef struct Lnode{...
guofu11111111111111.rar_单链表_单链表 c语言_线性链表程序
07-13
用c＋＋语言编写的程序，实现一个带头节点的非递减单链表存储结构的线性表。此程序能实现的基本算法有：初始化单链表，销毁单链表，插入元素，删除元素，清空单链表，打印线性表表和合并单链表。
shujujiegou.rar_C 单链表 排序_单链表
09-23
编写程序完成单链表的创建、插入、删除、排序、并、交、差运算、及输出等基本操作。
实验一_有序单链表合并_
10-03
【问题描述】1、建立两个有序的单链表，表中元素的数据类型自己指定；2、将建立的两个链表合并为一个新的有序的单链表；3、输出显示已合并好的有序的单链表。【输入形式】输入表1的元素个数，表1的元素值（逆序），...
单链表_单链表_
10-01
一个简单的单链表，具有插入删除打印等功能
单链表总结
07-11
很久的学习心得 希望对你有点用处
单链表的学习总结
Peter_tang6的博客
08-01 7104
前面学习了单链表的一些基本操作，这篇文章对在学习单链表的过程中遇到的一些问题做一些总结。初学单链表，很多东西都很难理解，因为之前的C语言基础的指针这块不是很熟悉，对于指针的操作很模糊，在一边百度一边看视频学习的过程中，渐渐加深了对指针的理解，以及对程序的模块化编程的学习。分不清楚头结点和头指针我学习的是没有头结点的，即只有一个头指针，在写代码的时候我总是会把头指针误认为一个头结点，然后定义另一个指针
单链表一些总结
一棵小树
07-22 259
转载自http://blog.csdn.net/luckyxiaoqiang/article/details/7393134
单链表问题总结
zlp1992的专栏
08-25 2864
Leetcode 单链表相关问题解决 判断链表是否存在环 找出环的入口节点
单链表知识汇总
tjh1998的博客
01-23 325
数据结构入门，单链表的尾插 当链表为空时 当链表不为空时 第一种情况，当p为空时， 第二种情况： 当链表不为空时 if(p=NULL) plist->head =s; else { while(p-next!=NULL) p=p->next; p->next=s; } 链表的头插 代码的实现 SListNode* s = _Buynode(); s->data = x; s->next = plist->head; plist->head
对于单链表的学习总结
qq_42252488的博客
10-06 2820
目录 1.单链表简介 2.单链表的初始化 3.单链表的删除，插入，和输出。 4.程序运行结果。 1.单链表简介 单链表分为两种，一种叫做顺序表另外一种叫做链式表，它们的不同之处在于顺序表示按照顺序映射的方式储存的，数组就是典型的顺序表。这种表的特点是栈储存，空间申请过程比较简单，但是这种链表在进行插入，删除登操作时往往具有很大的空间复杂度以及时间复杂度，就举个例子说：假如你要要往一个顺...
关于单链表的一些小结
她的吻让他
06-27 564
链表算是C语言中比较重要一个知识点了,之前学习时粗略的学过链表,这次回过头来回顾一下首先是链表的前置知识结构体和指针,链表就是一个结构体内有一个指向本类型的指针,这样一个一个串起来形成逻辑上的连续存储.#define Sfault 0 #define Strue 1 typedef char NodeDataC; typedef int NodeDataI; typedef struct N...
用C语言实现以下功能： 创建单链表 S_Num，头插法或尾插法逐字赋值为你的学号 打印单链表
最新发布
03-13
以下是用C语言实现创建单链表 S_Num，头插法逐字赋值为学号并打印单链表的代码： ```c #include #include struct Node { char data; struct Node* next; }; void printList(struct Node* head) { struct ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值