您的位置:首页 > 理论基础 > 数据结构算法

刚开始学数据结构不太明白?8000字吐血总结数据结构之单链表

2021-09-26 18:18 1031 查看

单链表详解

  • 三、单链表的实现
  • 四、LeetCode和剑指Offer上的单链表面试题
  • 五、其他练习题
  • 一、前言

    在上篇文章中,我们详细的讲解了顺序表,这里链接给大家放在下面。没看过的同学可以看一看,因为单链表就是在顺序表之上,做出优化的线性表。

    新学期预习吗?保姆级讲解数据结构之顺序表的9个方法+手撕代码

    大家还记得顺序表中的add方法吗?那写起来简 20000 直是一个麻烦,又要考虑pos下标是否合法,还得一个一个的把后面的元素移到前面,这样一来,不仅代码写起来麻烦,代码执行的时间复杂度也高。但也不是没有优点。

    顺序表:由数组构成,那么它也就包含了数组的特性。

    优点:
    1、查询元素时非常方便快捷,可以通过一个下标,能够快速的找到当前的数据。O(1).

    缺点:
    1、每次都会浪费大小不等的内存,假设当前数组大小为20;如果你要放第21个元素的时候,就需要扩容,假设扩容2倍后,大小是40,只放一个元素,那么剩下19个就浪费掉了。
    2、每次扩容的时候,都需要拷贝数组的内容,拷贝的过程中也是需要时间的,造成一定程度资源的浪费。
    3、删除和插入数据的时候,都需要移动数据。

    那么问题来了,有没有一种表,又不浪费内存,删除、插入数据的时候还方便快捷呢?

    这时候能够解决上面三个问题的链表来了!

    二、什么是链表?

    2.1、链表的概念:

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


    2.2、链表的分类:链表的结构非常多样化,根据带头和不带头,双向和单向,循环和不循环可以组成很多种链表。


    随便链表的种类有很多,但是只需要重点掌握两种即可。

    2.2、两种重要的单链表

    1、无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。


    1、无头双向循环链表:在Java集合框架当中,LinkedList的底层就是由这种链表实现的。


    注意:每个链表的400、200、300均为节点的引用地址,实际上是以16进制的方式存储的,这里我为了画图方便,进行了简写。

    2.3、关于单链表的一些基础知识

    1、链表在逻辑上是连续的,但是物理上不一定是连续的。这里的物理上,指的是内存地址上。

    2、单链表的值域:
    对于单链表来说,每一个节点都3个属性,在下图中最上面的123,指的是当前节点的地址(本来应该是16进制,这里为了方便说明用10进制)。val域:val是value的缩写,就是值的意思,这里存放的是当前节点需要存储的信息。
    next域:它的类型是一个节点类型。由于单链表在逻辑上是连续的,故对于一个节点来说,它不仅需要存放自己的val值,它还需要存放自己的下一个节点的地址->next,以此来实现逻辑上的连续。


    3、单链表的结构

    头节点+数据节点

    三、单链表的实现

    光说不练假把式,我们了解了链表的结构、用处。现在我们来亲手实现一个自己的单链表。

    3.1、穷举法创建一个简单的链表

    这里我先用穷举的方式一一创建节点,这样方便理解,下文再讲述用其他方法创建链表

    public class MylinkedList {
    public  ListNode head;//标识这个链表的头
    /**
    * 穷举法,最简单的方式把链表一个一个列举出来。
    */
    public  void createList(){
    ListNode listNode1=new ListNode(12);
    ListNode listNode2=new ListNode(13);
    ListNode listNode3=new ListNode(23);
    ListNode listNode4=new ListNode(33);
    ListNode listNode5=new ListNode(44);
    listNode1.next=listNode2;
    listNode2.next=listNode3;
    listNode3.next=listNode4;
    listNode4.next=listNode5;
    //head引用 引用的是listNode1引用 引用的对象
    this.head=listNode1;
    
    }
    }
    class ListNode{
    public  int val;//值
    public ListNode next;//储存下一个节点的地址,它是一个引用
    
    /**
    * 不带参数的构造方法
    */
    public  ListNode(){
    
    }
    /**
    * 带一个参数的构造方法
    */
    public  ListNode(int val){
    this.val=val;
    }
    }

    现在链表有了,那么问题来了,数组可以通过for循环的方式遍历链表,或者直接通过数组下标找到某个节点,那如何遍历链表当中的每个元素呢?

    先看这样一行代码:

    head=head.next;

    大家都知道head代表的是头结点的一个引用。这行代实际上是在修改引用,那把head修改到哪里呢?next指的是当前节点的下一个节点的地址,那么head.next意思就是head的下一个节点,这行代码就是让head走到它下一个节点的位置。现在它走到了listNode2的位置。

    接下来再看这样一行代码

    head=head.next.next

    聪明如你,假如当前head是listNode2,那么head.next就是listNode3的地址就指的是234,它后面再加一个next,就再指向在一个地址就是了。所以它的意思是让从listNode2走到listNode4的位置。

    慢慢的我们发现,我们可以通过head=head.next的方式让head这个引用不停的指向下一个节点,这难道不就是在遍历链表吗?我们让head走头开始,每走过一个节点,打印一个节点对应的val值。直到走到最后一个节点。

    接下来我们来实现这个方法。

    3.2、遍历链表

    上面我们已经知道了遍历链表的方式是让head一直等于head.next。我们如果需要遍历整个链表,就需要给他加一个限制条件。考虑到head具有特殊的含义,我们这里用一个cur节点来遍历链表。this.head=!null

    /**
    *遍历链表
    *
    */
    public  void disPlay(){
    ListNode cur=this.head;
    while (cur!=null){
    /**
    * 注意不能while循环的判断条件不能写成
    * this.head.next!=null。
    * 这样的话,最后一个节点是不能被打印的
    *
    */
    System.out.println(this.head.val);
    cur=cur.next;
    }
    System.out.println();
    }

    总结:如果想遍历完链表,一定得是cur!==null,这样才算是遍历完了。

    有了上面的基础,接下来我们在实现一些更复杂的方法。

    3.3、得到链表的长度

    思路是遍历一遍链表,定义一个计数器count,每遍历一个节点就让count+1,遍历完成后,返回count的值就是链表的长度了。

    上代码!

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

    size方法和display方法差别在多了一个计数器,在同样遍历遍历的基础下,display方法是打印链表的val值,而size方法是让计数器count+1.

    3.4、头插法

    1、刚刚我们以穷举法这样的方式创建了一个链表,现在我们用头插法创建链表。

    对于两种链表,两种不同的头插法方式。

    (1):对于无头单向链表。


    用蓝色字体的Node节点是需要头插的节点,它当前的val值是110,地址是777,next域是null。对于没有头结点的链表,头插法就是直接把需要插入的节点放到当前链表的第一个位置即可。

    如图:

    对于单向有头链表头插法就需要把插入的元素放到head节点和head下一个节点直接,因为有头的链表,head不能变。

    如图:

    上代码!

    //头插法   无头单向链表
    public void addFirst(int data){
    ListNode Node=new ListNode(data);
    Node.next=this.head;
    this.head=Node;
    }

    3.5、尾插法

    尾插法顾名思义,和头插法相似,尾插法把需要插入的节点插入到链表的尾部即可。但是问题来了,头插法可以直接插是因为链表本来就有head节点,但是链表并没有特别指出尾巴在哪里。所为尾插法第一个要做的是就是找到链表的尾巴,然后在插入到最后。修改next。

    1、找尾巴:找尾巴还是和size方法类似,定义一个cur节点,让他一直遍历,直到cur.next==null,就找到尾巴了。这时停止循环,不然就指向下一个节点。

    2、修改next:找到尾巴之后,让cur.next=Node就好。让链表原本的尾巴,指向现在的Node节点。


    3、还有一件事:万一链表是空的呢?那就是第一次插入了,这时直接让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;
    }
    }

    3.6、 任意位置插入节点

    这个方法的意思就是在某一个位置,插入一个节点。第一个数据节点为0号下标,以此类推。

    这时,需要修改的域有,上一个节点的next域,因为插入后它的next域就应当是当前插入节点的地址了,还有就是当前节点的next域,把它的next域修改成原本3号下标节点的地址。以下是插入的步骤和特殊情况处理。

    我们先相处一个基础版的代码:

    node.next=cur.next;
    cur.next=node;

    0、index位置小于0或者比链表长度还大怎么办?

    1、需要找到插入位置的前一个节点的地址,在上图是需要先找到1号下标节点的地址。

    2、0位置可没有前一个节点。

    3、要插入到最后一个节点怎么做?

    这些问题,都会在代码中解决。

    4、找到index下标前一个节点的方法 findInddexSubOne
    让一个引用从头开始,走index-1步,这是这个引用指向的就是前一个节点。

    /**
    * 让一个引用从头开始,走index-1步
    * @param index
    * @return
    */
    public  ListNode findInddexSubOne(int index){
    int count=0;
    ListNode cur=this.head;
    while (count!=index-1){
    cur=cur.next;
    count++;
    }
    return  cur;
    
    }

    整个方法代码如下:
    它有点长,你忍一下。

        //任意位置插入,第一个数据节点为0号下标
    public void  addIndex(int index,int data){
    //1、判断index是否合法
    if(index<0 ||index >size()){
    System.out.println("index位置不合法");
    return;
    }
    //2、index为0,直接头插法
    if(index==0){
    addFirst(data);
    return;
    }
    
    //3、index==size(),直接尾插法
    if(index==size()){
    addLast(data);
    return;
    }
    
    /**
    * 4、正常的情况
    *  cur指向的是一个index-1位置的节点
    */
    ListNode cur=findInddexSubOne(index);
    ListNode node=new ListNode(data);
    node.next=cur.next;
    cur.next=node;
    }
    
    /**
    * 让一个引用从头开始,走index-1步
    * @param index
    * @return
    */
    public  ListNode findInddexSubOne(int index){
    int count=0;
    ListNode cur=this.head;
    while (count!=index-1){
    cur=cur.next;
    count++;
    }
    return  cur;
    
    }
    

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

    遍历链表,定义一个cur引用,从链表的头开始,如果cur的val值和key相等了,就返回true,如果遍历完了,还没有找到,那就是没有,返回false。

    方法代码如下:

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

    3.8、删除所有节点

    由于链表是都 next域一个个连接起来的,那么删除所以节点的一个粗暴的方法就是把所有的next置空,让每个节点都找不到下一个节点,这样链表就连接不起来,就算是删除了。

    第一次尝试:我们试试是否可以像之前遍历链表一样,将每次经过的cur节点置空它的next域,这样就把整个链表删完了。

    但是当我们实际操作的时候发现,当你将cur节点的next域删除的时候,那它要怎么找到下一个节点呢?

    我们在定义一个节点curNext保存cur下一个节点就是了。这样每次删除的时候,curNext还可以指向下一个节点。删除完之后再让cur指向curNext。

    还有一件事!
    节点还有头结点没有删除,所以当循环走完,我们还需要让head节点置空,这样就是真正的把所有节点删除了。

    上代码!

    //删除所有节点
    public void clear(){
    ListNode cur=this.head;
    while (cur!=null){
    ListNode curNext=cur.next;
    cur.next=null;
    cur=curNext;
    }
    this.head=null;
    }

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

    假设要删除的节点是6,下标为del,我们只需要找到它的前驱节点prev,直接让这个前驱节点和del的下一个节点相连,就变向的忽略的del节点,这就算是删除这个这点了。

    总结:
    1、找到待删除节点的前驱节点和下一个节点
    2、将前驱节点的next域指向待删除节点的next域。
    3、有一种特殊情况是头结点是需要删除的节点。那么直接置空就好。

    具体细节都在代码中,找到前驱节点我写成了一个方法search在下面的代码中

    //找到前序节点 服务于  删除第一次出现关键字为key的节点
    public  ListNode searchPrev(int key){
    ListNode prev=this.head;
    while (prev!=null){
    if(prev.next.val==key){
    return  prev;
    }
    prev=prev.next;
    }
    return  null; //找完了都没返回,说明没有找到这个节点。
    }

    删除方法

    //删除第一次出现关键字为key的节点
    public void remove(int key){
    //0、头结点是要删除的节点
    
    if(this.head.val==key){
    this.head=this.head.next;
    return;
    }
    //1、找到要删除节点的前驱节点
    ListNode prev=searchPrev(key);
    if(prev==null){
    System.out.println("没有你要删除的节点");
    return;
    
    }
    //2、开始删除节点
    ListNode del=prev.next;
    prev.next=del.next;
    }

    3.10、删除所有值为key的节点

    1、上面我们已经写了9个方法了,相信大家单链表已经掌握的不错了,这是最后一个方法。我们这次将难度上升到面试的高度! 在只遍历链表一遍的情况下,删除所有值为key的节点。

    如下图,有两个val值为45的节点,我们这个方法需要只遍历链表一遍,就删除这两个val值为45的节点。

    思路:
    1.定义cur为当前要删除的节点,prev为删除节点的前驱节点,每次判断cur.val是否等于key,如果等于key就把prev.next指向cur.next。如果不相等,就让cur和prev一起向后走。

    上代码

    //删除所有值为key的节点
    public void removeAllKey(int key){
    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;
    }
    }

    只遍历一遍就完成了删除所以val值等于key的节点。你真棒!

    四、LeetCode和剑指Offer上的单链表面试题

    上面学习完了,怎么创建一个自己单链表,并且完成了单链表的10个方法,现在来试试挑战面试题把。题解在下方,加油哦!

    剑指 Offer II 021. 删除链表的倒数第 n 个结点

    LeetCode 24:两两交换链表中的节点、1662. 检查两个字符串数组是否相等

    leetcode 21. 合并两个有序链表

    五、其他练习题

    我还总结了一些LeetCode和剑指offer的题解,一起来看看吧!。

    剑指 Offer 67. 把字符串转换成整数

    怎么把i am a student逆置成student a am i?面试题逆置字符串讲解

    三种方法任君挑选 LeetCode_136只出现一次的数字

    什么?动态规划10行求出连续子数组的最大和 剑指offer-42讲解

    剑指 Offer 39. 数组中出现次数超过一半的数字 简单易懂14行搞定 。人人皆可会

    二叉树的层序遍历原理+LeetCode真题练习

    剑指 Offer 58 - II. 左旋转字符串的三种解法一起看看吧!!

    字符串“aabcccccaaa”压缩成“a2b1c5a3“还要返回更小的?力扣面试题 01.06. 字符串压缩讲解

    字符串bit666keji123“中数字的个数?

    找到不重复的数字进阶版 空间复杂度O(1),时间O(n)平方,不能修改数组内容。不能对数组进行排序

    LeetCode_231. 判断一个数是否为2 的幂,与运算一行代码解决

    验证尼科彻斯定理,即:任何一个整数m的立方都可以写成m个连续奇数之和

    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: