数据结构之单链表_next域数据类型，就是这么简单

2401_83946722

于 2024-04-20 18:53:11 发布

阅读量879

点赞数 16

分类专栏： 2024年程序员学习文章标签：数据结构

本文链接：https://blog.csdn.net/2401_83946722/article/details/138007658

版权

2024年程序员学习专栏收录该内容

266 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）

正文

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的节点。你真棒!

在这里插入图片描述