devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【数据结构】线性表之单链表_node *q=head什么意思

作者：笔触狂放9 | 2024-06-28 21:53:29

赞

踩

node *q=head什么意思

目录

一、链表的概念

1、概念

2、分类

3、重点

二、单链表模拟实现

1、准备

2、头插法

3、尾插法

 4、指定下标插入

5、遍历

6、删除第一次出现的元素key

7、删除所有的key

8、双指针删除所有的key

一、链表的概念

1、概念

是一种物理存储结构上非连续的存储结构，但逻辑上是连续的一种数据结构

2、分类

单向或双向

带头或者不带头

循环或者非循环

3、重点

后续重点学习无头单向非循环链表也就是单链表，他结构简单，一般不单独使用存储数据而是常作为其他数据结构的子结构比如哈希桶、图的临近表。还有一个是双向非循环链表，Java集合类里的LinkedList底层就是这一数据结构

二、单链表模拟实现

1、准备

一个单链表有多个节点，而每个节点都有一个存放数据的地方，我们叫他数据域，还有一个存下一个节点地址的地方，我们叫他指针域

  1. public class SingleLinkedList {
  2.     static class Node{
  3.         public int val;   //数据域
  4.         public Node next; //指针域
  5.  
  6.         /**
  7.          * 构造节点
  8.          * @param val  节点的数据
  9.          */
  10.         public Node(int val) {
  11.             this.val = val;
  12.         }
  13.     }
  14. }

2、头插法

先创建节点，创建节点后，将节点的指针域指向原来链表的头节点

此时需要更新头节点的位置，让头节点指向新增的节点 

 

 

  1. /**
  2.      * 头插法
  3.      * @param data  数据
  4.      */
  5.     public void addFirst(int data){
  6.         Node node = new Node(data);  //创建节点
  7.  
  8.         node.next = head;            //将该节点的指针域指向头节点
  9.         head = node;                 //再将头指针指向这个新的节点完成头插
  10.     }

3、尾插法

尾插法分两种情况：1.链表有节点，此时只需找到最后一个节点，然后将最后一个节点的指针指向插入的节点即可

再找最后一个节点时要注意，再循环里让cur遍历时，循环结束的条件不能是cur != null此时当循环结束，cur不是指向最后一个节点而是null。要找到最后一个节点 循环结束的条件是cur.next != null

2.第二个情况则是，如果此时链表没有任何元素，插入的为第一个元素，则直接让头指针指向他即可

  1. /**
  2.      * 尾插法
  3.      * @param data  尾插的数据
  4.      */
  5.     public void addLast(int data){
  6.         Node node = new Node(data);   //创建节点
  7.         
  8.         if(head == null){             //如果此时没有任何节点，则直接将头节点指向他
  9.             head = node;
  10.             return;
  11.         }
  12.         
  13.         Node cur = head;              //代替头节点遍历链表直到最后一个节点时停止
  14.  
  15.         while(cur.next != null){
  16.             cur = cur.next;
  17.         }
  18.         
  19.         cur.next = node;              //此时cur指向最后一个节点，此时只需将他的指针域指向新的节点即可
  20.     }

 4、指定下标插入

指定的位置插入数据，比如在2下标插入数据，此时我们先得找到前一个。让前一个节点的next指向新增的节点，然后将新节点的next指向第二个节点，不过此处要注意如果我们先让2的前一个节点指向新的节点，在第二部将新节点的next指向2的时候会发现丢失了，所以此处可以先让新节点的next指向2位置的节点，在让前面的节点next指向新的节点，综上所述，分为以下主要步骤：找到前驱节点，让新增节点的next指向前驱节点的下一个节点，然后再将前驱节点的next 指向新增节点

 

 

 

  1.  /**
  2.      * 中间指定位置插入
  3.      * @param index  指定插入下标
  4.      * @param data   插入的数据
  5.      */
  6.     public void addIndex(int index,int data){
  7.         //1.判断下标是否合法
  8.         if(index < 0 || index > size()){
  9.             throw new ArrayIndexOutOfBoundsException("非法下标");
  10.         }
  11.  
  12.         //2.处理特殊情况
  13.         if(index == 0){
  14.             addFirst(data);                  //如果插头则调用头插
  15.             return;
  16.         }
  17.  
  18.         if(index == size()){
  19.             addLast(data);                   //如果插尾则调用尾插
  20.             return;
  21.         }
  22.  
  23.         //3.找到前驱节点
  24.         Node pre = searchPrevNodeToAdd(index);  //找到前一个节点
  25.  
  26.         //4.开始插入
  27.         Node node = new Node(data);       //创建节点
  28.         node.next = pre.next;             //让新增节点的next指向前驱节点的下一个
  29.         pre.next = node;                  //再将前驱节点的next指向新增节点
  30.     }
  31.  
  32.     /**
  33.      * 新增时找前驱节点
  34.      * @param index   待插入的下标
  35.      * @return        前驱节点
  36.      */
  37.     private Node searchPrevNodeToAdd(int index) {
  38.         Node cur = head;
  39.  
  40.         while(index-- != 1){
  41.             cur = cur.next;
  42.         }
  43.  
  44.         return cur;
  45.     }

5、遍历

链表的遍历，定义一个指针代替头节点进行循环遍历 

6、删除第一次出现的元素key

要删除node这个节点时，我们需要先找到他的前一个节点，然后让他前一个节点指向他的后一个节点，所以现在我们先需要找到前一个节点，然后再删除。

  1.  
  2.     /**
  3.      * 删除节点时找前驱节点
  4.      * @param key  关键字
  5.      * @return     前驱节点
  6.      */
  7.     private Node searchPrevNodeToRemove(int key) {
  8.         Node cur = head;
  9.         while(cur.next != null){         //要找的是前驱节点
  10.             if(cur.next.val == key){
  11.                 return cur;
  12.             }
  13.             cur = cur.next;
  14.         }
  15.  
  16.         return null;             //没找到返回空
  17.     }

此处找前驱节点的代码里遍历链表退出循环的条件使用的是cur.next != null此处要注意，如果使用cur!=null，链表遍历到最后一个节点时cur!=null满足条件进入循环里的if cur.next.val由于是最后一个节点所以他的next是空的，此时空的再去访问val则会空指针异常 

 找到前驱节点后进行删除，要注意处理看头节点是不是符合删除的条件

  1. /**
  2.      * 删除第一次出现的指定节点
  3.      * @param key
  4.      */
  5.     public void remove(int key){
  6.         //1.是否为空
  7.         if(head == null){
  8.             return;
  9.         }
  10.  
  11.         //2.判断头节点是不是
  12.         if(head.val == key){
  13.             head = head.next;
  14.             return;
  15.         }
  16.  
  17.         //3.找到前一个节点
  18.         Node pre = searchPrevNodeToRemove(key);
  19.         if(pre == null) return;
  20.  
  21.         //4.正常删除
  22.         pre.next = pre.next.next;
  23.     }
  24.  
  25.     /**
  26.      * 删除节点时找前驱节点
  27.      * @param key  关键字
  28.      * @return     前驱节点
  29.      */
  30.     private Node searchPrevNodeToRemove(int key) {
  31.         Node cur = head;
  32.         while(cur.next != null){         //要找的是前驱节点
  33.             if(cur.next.val == key){
  34.                 return cur;
  35.             }
  36.             cur = cur.next;
  37.         }
  38.  
  39.         return null;             //没找到返回空
  40.     }

7、删除所有的key

删除所有的key,我们可以定义一个指针指向头节点，让他去遍历链表，遍历的过程如果有满足条件的就删除

  1. /**
  2.      * 删除所有的key
  3.      * @param key
  4.      */
  5.     public void removeAll(int key){
  6.         //1.判断是否空
  7.         if(head == null){
  8.             return;
  9.         }
  10.  
  11.         //2.遍历删除
  12.         Node cur = head;
  13.         while(cur.next != null){
  14.             if(cur.next.val == key){
  15.                 cur.next = cur.next.next;
  16.                 continue;
  17.             }
  18.             cur = cur.next;
  19.         }
  20.  
  21.         //3.处理头节点
  22.         if(head.val == key){
  23.             head = head.next;
  24.         }
  25.  
  26.     }

上述代码要注意的是，处理头节点要放在遍历删除之后，如果头节点满足条件第二个节点也满足条件，此时删除了头进入循环时新的头节点也是key,但是循环里的逻辑是不能删除满足条件的头节点的，所以放在后面进行处理。而在上面只删除第一个key，把处理头节点放在循环前的原因是他只是删除第一个分先后顺序删除

8、双指针删除所有的key

定义两个指针，一个作为遍历指，一个作为遍历指针的前驱指针，让遍历指针遍历链表的同时进行判断他当前的节点是否满足删除条件，如果满足则前驱节点的next指向当前节点的next直接跳过当前节点删除，然后遍历指针指向下一个节点，如果不满足则让前驱节点指向当前节点，当前节点指向下一个节点

  1.  /**
  2.      * 双指针删除所有的key
  3.      * @param key
  4.      */
  5.     public void removeAllByDoublePointer(int key){
  6.         //1.判空
  7.         if(head == null){
  8.             return;
  9.         }
  10.  
  11.         //2.双指针删除
  12.         Node pre = head;
  13.         Node cur = head.next;
  14.         while(cur != null){
  15.             if(cur.val == key){
  16.                 pre.next = cur.next;
  17.             }else{
  18.                 pre = cur;
  19.             }
  20.             cur = cur.next;
  21.         }
  22.  
  23.         //3.处理头节点
  24.         if(head.val == key){
  25.             head = head.next;
  26.         }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/767406
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号