顺序表和链表02——单链表的实现

逆袭者—MA

已于 2022-05-02 10:13:53 修改

阅读量965

点赞数 3

分类专栏：数据结构——线性表单链表文章标签：链表数据结构 java

于 2022-04-30 12:09:33 首次发布

本文链接：https://blog.csdn.net/m0_61608447/article/details/124497333

版权

数据结构——线性表同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

单链表

2 篇文章 0 订阅

订阅专栏

1. 前言

在写动态数组时，会发现存在一些的问题：

1. 顺序表中间/头部的插入删除，时间复杂度为O(N)

2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。

例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

思考：如何解决以上问题呢？可以使用线性表中的链表。

2.链表

2.1 链表的概念及结构

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

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

单向、双向

带头、不带头

循环、非循环

虽然有这么多的链表的结构，但是我们重点掌握两种

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。.

无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

其实说白了，就是自定义一个类，一个变量保存值，一个变量保存下一个节点的地址。

2.2理解单链表

可以把单链表想象成一辆火车，火车的不同车厢之间，都是通过一个挂钩连接的，当这两个这厢脱钩后，这两个车厢就没有任何关系了。

不像我们之前学的数组，相邻的两个元素不仅逻辑上连续，物理也连续。

而我们这次学的单链表，是逻辑连续，物理不连续。

每节车厢都是通过挂钩相连接的，这种结构就叫做链表。

多个节点（车厢）之间用一个 “小挂钩”（地址）相连接的方式叫做链表。

数组的话两个元素之间紧紧相连没有空隙，这就是数组。

﹒假设咱们现在每节火车车厢只保存一个int值，这个值就是我们要存储的数据，每节车厢还要保存一个下—节车厢的地址。

所谓的单链表指的是，只能从头节点开始从前走到后，每个节点只保存了下一个节点的地址，一个方向遍历的链表结构。

那么类的节点如何定义 ——》每节火车的车厢

如：class Node(){

}

这里面该怎么写？

保存数据很简单，看个人的需求。

如果你想保存一个人的年纪就用 int age；

如果你想保存一个人的名字就用 String name；

如果你想保存一个人的身高就用 double height;

等等...........

关键来了，如果保存下一个节点的地址，用什么？

其实很简单，因为我们产生的对象都是 Node类型（自定义的类），保存地址当然是用Node类型来保存

如：

class Node(){

int age；

Node next；

}

注释：链表的尾部节点里面保存的地址应该是默认值null，用来判断这个链表走到头了。

我们说了 Node类表示的是每个火车节点,每个链表的节点

那么到底啥是链表？====>由若干个链表节点构成的对象就称为链表

如上图中五个节点构成的一个整体成为链表。

我们先是创建了一个Node类，用来表示车厢，但它们都是相互分散，没有丝毫关联的个体，想要把它们全都连接在一起进行一系列操作的话，就还需要创建一个类（火车头）

Single linked list 用来表示火车头类。

里面最需要写什么?--一个火车的头部，我给你一个火车的火车头Node head;
我就能遍历当前这个链表中所有的节点从head开始向后遍历。

还需要写一个 int size，用来记录当前创建的节点个数。

head 和 size 一个单链表中最重要的两个成员变量

2.3接口实现

/**
 * 增加
 *  addFirst(int val)  头插
 *  add(int index, int val) 在任意索引index处插入节点
 *  addLast(int val) 尾插
 *
 * 查找
 *  getByValue(int val) 查询第一个值为 val的索引为多少 不存在则返回 -1
 *  get(int index) 查询索引为index处的节点值为多少
 *  contains(int val) 查询是否包含指定值的节点
 *
 *  修改
 *  set(int index, int newVal) 修改索引为index位置的结点值为 newVal，返回修改前的节点值
 *
 *  删除
 *   remove(int index) 删除 index 处的节点,并返回删除的节点值
 *   removeFrist() 头删
 *   removeLast()  尾删
 *   removeValue(int val)  删除第一个值为val的节点，并返回它索引
 *   removeAllValue(int val)  删除全部值为 val 的节点
 */

1. 准备工作，先创建节点类（车厢）

/**
 * 单链表的具体的每个节点 - 车厢类
 */
class Node{
    
    int val;//每个节点保存的值
    Node next;//当前节点的下一个节点地址
    
}

2. 准备工作，创建一个单链表（火车头）

/**
 * 基于int的单链表 - 火车
 * 真正被用户使用的是火车类-单链表对象
 */
public class Single_linked_list {

    private Node head;//链表的头节点---火车头
    private int size;//记录有效节点的个数
    
}

注释：

1. 用户只需要调用单链表提供的增删改查方法即可
至于链表内部节点如何连接的，如何遍历的用户都不关心。

2. 增删改查都在单链表这个类中定义。

3. 链表章节，一定下来多画图，先把图画明自!! ! !

3. 实现头插--分为链表为空和不为空的情况

    /**
     *  向当前的链表中添加一个新的节点，默认在链表的头部添加
     * @param val
     */
    //头插
    public void addFirst(int val){

        Node node = new Node();//创建一个新节点
        node.val = val;

        if(head == null){
            //此时链表为空,第一个节点即为头节点
            head = node;
        }else{
            //此时链表不为空
            node.next = head;//新节点保存现在的头节点地址
            head = node;//头节点保存新的节点地址
        }

        size++;

    }

4. 为了测试功能，完善下toString方法。因为System.out.println方法里面输入对象时，打印的是改对象类似于地址值（由哈希计算得出），但我们想要打印出单链表里面的具体内容，就需要手动完善下单链表的重载。

    /**
     * 完善一下toString方法
     */
    public String toString(){
        String rep = "";
        //一定要创建一个变量来变量，如果直接用
        //head来变量的话就丢失原来的地址，找不到头节点了
        for (Node x = head; x != null ; x = x.next) {
            //走到尾节点为null地址算结束
            rep += x.val;
            rep += " -> ";
        }
        rep += "NULL";//用来表示链表走到空了
        return rep;
    }

5. 创建一个测试类：Test_single

//测试单链表功能
public class Test_single {
    public static void main(String[] args) {

        Single_linked_list sll = new Single_linked_list();
        sll.addFirst(5);
        sll.addFirst(4);
        sll.addFirst(3);
        sll.addFirst(2);
        sll.addFirst(1);
        System.out.println(sll);

    }
}

6. 其实刚刚写的头插法还可以写的更加方便简单，就是运用我们之前学的构造方法

先在Node写有参构造

新的Node

/**
 * 单链表的具体的每个节点 - 车厢类
 */
class Node{

    int val;//每个节点保存的值
    Node next;//当前节点的下一个节点地址
    
    //无参构造
    public Node() { }

    //有参构造一
    public Node(int val){
        this.val = val;
    }
    //有参构造二
    public Node(int val, Node next){
        this.val = val;
        this.next = next;
    }

}

简洁版头插写法

    //头插--精简写法
    public void addFirst(int val){
        //头插时保存的地址都是当前头节点地址
        Node node = new Node(val, head);
        //如果不存在节点 head == null，那么这样赋值也合理
        
        head = node;//因为无论是否存在节点，head都会等于新节点地址
        size++;
        
    }

注释：不是为了节省代码而且节省，主要目的是要学会串联之前学的知识点。代码质量的提升。

注释：在类中如： Node node = new Node(val, head);其中的node并不是一个对象，而是一个跟对象类型一样的变量，跟 int double没什么区别，里面保存的是后面new出来对象的地址。不过node也是在堆区中开辟空间的。类似于下面的图

所以代码中我让 node = prve，其实只是让node变量里面保存prve里面的对象地址罢了。

都是通过这些地址去找对象在哪的。

提问：

Node prve = new Node();这条在存在中是怎么开辟空间的？

那么问题来了

prve.next = null； —————— prve = null；

这两个式子有什么区别？

prve = NULL

注释：这两幅图要弄懂，对写链表比较重要

7.在任意索引index处插入节点

想要在链表中插入一个节点，必须要找到前驱

如果想在第二个节点，索引为 1 的节点前插入一个节点该怎么做？

找到待插入节点的前驱节点位置

怎么找？循环 index - 1次，自己画图数数就知道了

注释：所有的节点中，只有头节点不具备前驱节点，所以要区别对待。

代码示例：

    /**
     *在任意索引index处插入节点
     */
    public void add(int index, int val){
        //对索引的合法性进行判断
        if(index < 0 || index > size){
            //在插入里面 index可以取到 size，相当于尾插
            System.out.println("插入索引值错误！");
            return;
        }
        //想要插入一个节点，就要找到待插入节点的前驱。
        //所有节点中只有头节点不具备前驱
        if(index == 0){
            addFirst(val);//头插
        }else{
            //开始找头节点，次数是 index - 1次
            Node prve = head;
            for (int i = 0; i < index - 1; i++) {
                 prve = prve.next;
            }//循环出来后说明已经是待插入节点的前驱了
            Node node = new Node(val, prve.next);//新节点连接前驱的下一个地址
            prve.next = node;
            size ++;
        }
    }

测试

//测试单链表功能
public class Test_single {
    public static void main(String[] args) {

        Single_linked_list sll = new Single_linked_list();
        sll.addFirst(5);
        sll.addFirst(4);
        sll.addFirst(3);
        sll.addFirst(2);
        sll.addFirst(1);
        System.out.println(sll);
        sll.add(0,9);
        System.out.println(sll);
        sll.add(6, 10);
        System.out.println(sll);

    }
}

8. 有了任意插做铺垫，尾插就显得很方便了。

    //尾插
    public void addLast(int val){
        add(size , val);
    }

9. 查询：写了三种方案

因为在查询和删除都需要判断索引的合理性，所以直接写了个 rangeCheck 方法判断合理性

    /**
     * 查询第一个值为 val的索引为多少
     * 不存在则返回 -1
     */
     public int getByValue(int val){

         Node x = head;
         for (int i = 0; i < size; i++) {
             if(x.val == val){
                 return i;
             }
             x = x.next;
         }
         //循环里面没找到就代表不存在
         return -1;//用 -1 表示
     }

    /**
     * 查询索引为index处的节点值为多少
     */
     public int get(int index){
         if(rangeCheck(index)){
             Node prve = head;
             //想走到index处的节点需要走 index 次
             for (int i = 0; i < index; i++) {
                 prve = prve.next;
             }
             return prve.val;
         }
         //走到这说明索引值不合理
         System.out.println("查询索引不合理");
         return -1;
     }
    /**
     * 查询是否包含指定值的节点
     */
     public boolean contains(int val){
         if(getByValue(val) == -1){
             return false;
         }
         return true;
     }


    /**
     * 判断给的index索引是否合理
     */
      private boolean rangeCheck(int index){
          if(index < 0 || index >= size){
              return false;
          }
          return true;
      }

测试：

//测试单链表功能
public class Test_single {
    public static void main(String[] args) {

        Single_linked_list sll = new Single_linked_list();
        sll.addFirst(5);
        sll.addFirst(4);
        sll.addFirst(3);
        sll.addFirst(3);
        sll.addFirst(2);
        sll.addFirst(1);
        System.out.println(sll);

        System.out.println("--------------------------");

        System.out.println(sll.getByValue(3));
        System.out.println(sll.getByValue(1));
        System.out.println(sll.getByValue(6));
        System.out.println("--------------------------");

        System.out.println(sll.get(2));
        System.out.println(sll.get(6));
        System.out.println("--------------------------");

        System.out.println(sll.contains(5));
        System.out.println(sll.contains(7));
    }
}

10. 在我们写代码的发现 for循环一直被多次重复利用，所以我们直接定义成一个方法，方便我们使用。功能：输入index索引，返回该节点的地址，不存在则返回 NULL

    /**
     * 给你一个index索引，返回给节点的地址，不存在则为null
     */
     private Node node(int index){
         if(rangeCheck(index)){
             Node rep = head;
             for (int i = 0; i < index; i++) {
                 rep = rep.next;
             }
             return rep;
         }
         System.out.println("索引值不合理");
         return null;
     }

11. 修改索引为index位置的结点值为newVal，返回修改前的节点值

有了上面写的node方法，写起来就方便多了

    /**
     * 修改索引为index位置的结点值为 newVal，返回修改前的节点值
     */
      public int set(int index, int newVal){
          Node cur = node(index);
          if(cur != null){
              int rep = cur.val;
              cur.val = newVal;
              return rep;
          }
          System.out.println("修改索引值不合理");
          return -1;
      }

测试

//测试单链表功能
public class Test_single {
    public static void main(String[] args) {

        Single_linked_list sll = new Single_linked_list();
        sll.addFirst(5);
        sll.addFirst(4);
        sll.addFirst(3);
        sll.addFirst(3);
        sll.addFirst(2);
        sll.addFirst(1);
        System.out.println(sll);

        System.out.println(sll.set(0, 7));
        System.out.println(sll.set(3, 9));
        System.out.println(sll);
    }
}

12.到了最后的功能模块，删除。

删除功能可以分为五种情况

1. 删除 index 处的节点

2. 头删

3. 尾删

4. 删除第一个值为 val 的节点

5. 删除全部值为 val 的节点

注释：删除是数据结构中最难的步骤，考虑的边界值必须要细心。

代码里面的注释部分需要仔细看看

    /**
     * 删除 index 处的节点,并返回删除的节点值
     */
      public int remove(int index){

          //需要考虑一种特殊情况，当size == 0没有节点时，不能删除了
          if(size == 0){
              return -1;
          }

          if(rangeCheck(index)){
              //删除一个节点其实也是在找前驱节点的过程
              //但头节点不存在前驱，所以需要特殊考虑
              if(index == 0){
                  //头删
                  Node cur = head;//保存原来的头节点
                  head = head.next;//头节点直接向后移一位
                  //真正删除一个节点最好的方式就是断开所有的连接线
                  //这样才会被JVMN视为系统垃圾被删除
                  cur.next = null;//置空
                  size--;//有效节点个数
                  return cur.val;//返回待删除节点的值
              }else{
                  //索引合法，不是头节点，那就找前驱
                  //我们之前写了 node方法找个index位置处的节点地址
                  //那么 index - 1就是前驱地址了
                  Node cur = node(index - 1);//前驱地址
                  Node node = cur.next;//待删除节点地址
                  cur.next = node.next;//前驱连接下一个的下一个节点地址
                  node.next = null;//断开连接，置空
                  size--;//有效节点个数
                  return node.val;
              }

          }
          System.out.println("删除节点的索引错误");
          return -1;
      }


     //头删
     public int removeFrist(){
          return remove(0);
     }
    //尾删
    public int removeLast(){
        return remove(size - 1);
    }


    /**
     * 删除第一个值为val的节点，并返回它索引
     */
     public int removeValue(int val){
         Node prve = head;
         for (int i = 0; i < size; i++) {
              if(prve.val == val){
                  remove(i);//删除
                  return i;//返回索引值
              }
              prve = prve.next;
         }
         return -1;//说明不存在val值
     }


      /**
     *  删除全部值为 val 的节点
     */
     public void removeAllValue(int val){

        //删除跟插入很像，都是找前驱的过程，但必须先处理头节点
         while(head != null && head.val == val){
              Node x =head;//保存待删除的头节点
              head = head.next;//头节点后移
              x.next = null;
              size--;
         }

         //判断是否被删完了
         if(head == null){
             return;
         }

         //到这里说明头节点不是待删除节点了，而且还要节点需要我们判断
         Node node = head;
         while( node.next != null){
             if(node.next.val == val){
                 Node cur = node.next;//保存待删除的节点
                 node.next = node.next.next;
                 cur.next = null;//断开
                 size--;
             }else{
                 // 只有当node.next.val != val才能移动node指针！
                 node = node.next;
             }
         }
     }

测试

//测试单链表功能
public class Test_single {
    public static void main(String[] args) {

        Single_linked_list sll = new Single_linked_list();
        sll.addLast(1);
        sll.addLast(2);
        sll.addLast(2);
        sll.addLast(2);
        sll.addLast(3);
        sll.addLast(5);

        System.out.println(sll);

        System.out.println(sll.removeFrist());
        System.out.println(sll);

        System.out.println(sll.removeLast());
        System.out.println(sll);

        sll.removeAllValue(2);

        System.out.println(sll);


    }
}

3. 力扣练习题

203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com)

4.代码总和


/**
 * 基于int的单链表 - 火车
 * 真正被用户使用的是火车类-单链表对象
 */
public class Single_linked_list {

    private Node head;//链表的头节点---火车头
    private int size;//记录有效节点的个数

    /**
     *  向当前的链表中添加一个新的节点，默认在链表的头部添加
     * @param val
     */
    //头插--平常写法
             /*
    public void addFirst(int val){

        Node node = new Node();//创建一个新节点
        node.val = val;

        if(head == null){
            //此时链表为空,第一个节点即为头节点
            head = node;
        }else{
            //此时链表不为空
            node.next = head;//新节点保存现在的头节点地址
            head = node;//头节点保存新的节点地址
        }
        size++;
    }
             */
    //头插--精简写法
    public void addFirst(int val){
        //头插时保存的地址都是当前头节点地址
        Node node = new Node(val, head);
        //如果不存在节点 head == null，那么这样赋值也合理

        head = node;//因为无论是否存在节点，head都会等于新节点地址
        size++;
    }

    /**
     *在任意索引index处插入节点
     */
    public void add(int index, int val){
        //对索引的合法性进行判断
        if(index < 0 || index > size){
            //在插入里面 index可以取到 size，相当于尾插
            System.out.println("插入索引值错误！");
            return;
        }
        //想要插入一个节点，就要找到待插入节点的前驱。
        //所有节点中只有头节点不具备前驱
        if(index == 0){
            addFirst(val);//头插
        }else{
            //开始找头节点，次数是 index - 1次
            Node prve = head;
            for (int i = 0; i < index - 1; i++) {
                 prve = prve.next;
            }//循环出来后说明已经是待插入节点的前驱了
            Node node = new Node(val, prve.next);//新节点连接前驱的下一个地址
            prve.next = node;
            size ++;
        }
    }
    //尾插
    public void addLast(int val){
        add(size, val);
    }

    /**
     * 查询第一个值为 val的索引为多少
     * 不存在则返回 -1
     */
     public int getByValue(int val){

         Node x = head;
         for (int i = 0; i < size; i++) {
             if(x.val == val){
                 return i;
             }
             x = x.next;
         }
         //循环里面没找到就代表不存在
         return -1;//用 -1 表示
     }

    /**
     * 查询索引为index处的节点值为多少
     */
     public int get(int index){
         if(rangeCheck(index)){
             Node prve = head;
             //想走到index处的节点需要走 index 次
             for (int i = 0; i < index; i++) {
                 prve = prve.next;
             }
             return prve.val;
         }
         //走到这说明索引值不合理
         System.out.println("查询索引不合理");
         return -1;
     }
    /**
     * 查询是否包含指定值的节点
     */
     public boolean contains(int val){
         if(getByValue(val) == -1){
             return false;
         }
         return true;
     }


    /**
     * 判断给的index索引是否合理
     */
      private boolean rangeCheck(int index){
          if(index < 0 || index >= size){
              return false;
          }
          return true;
      }

    /**
     * 给你一个index索引，返回给节点的地址，不存在则为null
     */
     private Node node(int index){
         if(rangeCheck(index)){
             Node rep = head;
             for (int i = 0; i < index; i++) {
                 rep = rep.next;
             }
             return rep;
         }
         System.out.println("索引值不合理");
         return null;
     }

    /**
     * 修改索引为index位置的结点值为 newVal，返回修改前的节点值
     */
      public int set(int index, int newVal){
          Node cur = node(index);
          if(cur != null){
              int rep = cur.val;
              cur.val = newVal;
              return rep;
          }
          System.out.println("修改索引值不合理");
          return -1;
      }

    /**
     * 删除 index 处的节点,并返回删除的节点值
     */
      public int remove(int index){

          //需要考虑一种特殊情况，当size == 0没有节点时，不能删除了
          if(size == 0){
              return -1;
          }

          if(rangeCheck(index)){
              //删除一个节点其实也是在找前驱节点的过程
              //但头节点不存在前驱，所以需要特殊考虑
              if(index == 0){
                  //头删
                  Node cur = head;//保存原来的头节点
                  head = head.next;//头节点直接向后移一位
                  //真正删除一个节点最好的方式就是断开所有的连接线
                  //这样才会被JVMN视为系统垃圾被删除
                  cur.next = null;//置空
                  size--;//有效节点个数
                  return cur.val;//返回待删除节点的值
              }else{
                  //索引合法，不是头节点，那就找前驱
                  //我们之前写了 node方法找个index位置处的节点地址
                  //那么 index - 1就是前驱地址了
                  Node cur = node(index - 1);//前驱地址
                  Node node = cur.next;//待删除节点地址
                  cur.next = node.next;//前驱连接下一个的下一个节点地址
                  node.next = null;//断开连接，置空
                  size--;//有效节点个数
                  return node.val;
              }

          }
          System.out.println("删除节点的索引错误");
          return -1;
      }


     //头删
     public int removeFrist(){
          return remove(0);
     }
    //尾删
    public int removeLast(){
        return remove(size - 1);
    }


    /**
     * 删除第一个值为val的节点，并返回它索引
     */
     public int removeValue(int val){
         Node prve = head;
         for (int i = 0; i < size; i++) {
              if(prve.val == val){
                  remove(i);//删除
                  return i;//返回索引值
              }
              prve = prve.next;
         }
         return -1;//说明不存在val值
     }


        /**
     *  删除全部值为 val 的节点
     */
     public void removeAllValue(int val){

        //删除跟插入很像，都是找前驱的过程，但必须先处理头节点
         while(head != null && head.val == val){
              Node x =head;//保存待删除的头节点
              head = head.next;//头节点后移
              x.next = null;
              size--;
         }

         //判断是否被删完了
         if(head == null){
             return;
         }

         //到这里说明头节点不是待删除节点了，而且还要节点需要我们判断
         Node node = head;
         while( node.next != null){
             if(node.next.val == val){
                 Node cur = node.next;//保存待删除的节点
                 node.next = node.next.next;
                 cur.next = null;//断开
                 size--;
             }else{
                 // 只有当node.next.val != val才能移动node指针！
                 node = node.next;
             }
         }
     }


    /**
     * 完善一下toString方法
     */
    public String toString(){
        String rep = "";
        //一定要创建一个变量来变量，如果直接用
        //head来变量的话就丢失原来的地址，找不到头节点了
        for (Node x = head; x != null ; x = x.next) {
            //走到尾节点为null地址算结束
            rep += x.val;
            rep += " -> ";
        }
        rep += "NULL";//用来表示链表走到空了
        return rep;
    }

}

/**
 * 单链表的具体的每个节点 - 车厢类
 */
class Node{

    int val;//每个节点保存的值
    Node next;//当前节点的下一个节点地址

    //无参构造
    public Node() { }

    //有参构造一
    public Node(int val){
        this.val = val;
    }
    //有参构造二
    public Node(int val, Node next){
        this.val = val;
        this.next = next;
    }

}