数据结构_5：链表与递归

链表与递归

链表元素删除问题的解答

问题描述：在链表[1, 2, 6, 3, 4, 5, 6] 中删除值为 6 的元素

• ListNode.java 结构说明

  public class ListNode {
      int val;
      ListNode next;
  
      ListNode(int x) {val = x;}
  
      /**
      * 链表节点构造函数，自定义
      * @param arr
      */
      ListNode(int[] arr) {
          if (arr == null || arr.length == 0) {
              throw new IllegalArgumentException("arr can not be empty");
          }
          this.val = arr[0];
          ListNode cur = this;
          for (int i = 1; i < arr.length; i++) {
              cur.next = new ListNode(arr[i]);
              cur = cur.next;
          }
      }
  
      @Override
      public String toString() {
          StringBuilder sb = new StringBuilder();
          ListNode cur = this;
          while (cur != null) {
              sb.append(cur.val).append(" -> ");
              cur = cur.next;
          }
          sb.append("NULL");
          return sb.toString();
      }
  }
  

• 常规方式，对链表的三个部分[头、中、尾]进行分别处理

  public ListNode removeElement(ListNode head, int val) {
          // 链表头部节点删除
          while (head != null && head.val == val)
              head = head.next;
  
          // 链表尾部节点删除
          if (head == null) {
              return null;
          }
  
          // 链表中间部分节点删除
          ListNode prev = head;
          while (prev.next != null) {
              if (prev.next.val == val)
                  prev.next = prev.next.next;
              else
                  prev = prev.next;
          }
  
          return head;
      }
  }
  

• 虚拟头结点方式，使得每个链表节点均含有前置节点，改进代码

   public ListNode removeElement(ListNode head, int val) {
      // 建立虚拟头结点，保证链表中每一个节点前面均有节点
      ListNode dummyHead = new ListNode(-1);
      dummyHead.next = head;
  
      // 链表节点删除
      ListNode prev = dummyHead;
      while (prev.next != null) {
          if (prev.next.val == val)
              prev.next = prev.next.next;
          else
              prev = prev.next;
      }
  
      return dummyHead.next;
  }
  

• 测试一下！

  public static void main(String[] args) {
      int[] arr = {1, 2, 6, 3, 4, 5, 6};
      ListNode res = new ListNode(arr);
      System.out.println(res);
      new Solution2().removeElement(res, 6);
      System.out.println(res);
  }
  ------------------------------------------
  1 -> 2 -> 6 -> 3 -> 4 -> 5 -> 6 -> NULL
  1 -> 2 -> 3 -> 4 -> 5 -> NULL
  

递归：计算机中的很重要的组件逻辑机制

• 本质上，将原来的问题，转化为更小的同一问题，比如数组求和！

  SUM(arr[0...n-1]) = arr[0] + SUM(arr[1...n-1])

  SUM(arr[1...n-1]) = arr[1] + SUM(arr[2...n-1])

  SUM(arr[n-1...n-1]) = arr[n-1] + SUM(arr[]) = arr[n-1] + 0

• 递归算法的组成

  • 求解最基本的问题
  • 把原问题转化成更小的问题

• 链表具有递归性质

  • 链表可以理解为多个节点的连接体，也可以看做一个节点和一个链表的连接体。
  • 而NULL也是是一个最基本的链表。
  • 为了方便理解，画了一张图！
    
  • 根据图，我们可以改写代码！

  public ListNode removeElementNew(ListNode head, int val) {
      // 基础问题 one
      if (head == null) {
          return null;
      }
      // 处理子链表，分解问题 two
      head.next = removeElementNew(head.next, val);
      // 处理结果，若当前返回子链表满足条件，便跳过节点 three
      return head.val == val ? head.next : head;
  }
  

  • 举个栗子，现在有链表1, 2, 3，想要删除元素2 上述方法是怎么执行的呢？
    • step1 入参【1, 2, 3】 以 1 为头结点的链表
      • one head != null
      • two head.next = ? ，进入第一次递归，step2
    • step2 入参【2, 3】 以 2 为头结点的链表
      • one head != null
      • two head.next = ?，进入第二次递归，step3
    • step3 入参【3】以3 为头结点的链表
      • one head != null
      • two head.next = ? ，进入第三次递归，step4
    • step4 入参【NULL】，NULL 链表
      • one head == null，返回 null，基本问题出现了！！！
    • step5 回到step3 two
      • two head.next = 【null】
      • three head.val == 2? head.next : head
      • return head ，此时链表为【3】，回到step2 two
    • step6 回到step2 two
      • two head.next = 【3】
      • three head.val == 2? head.next : head, 此时条件满足，为true
      • return head.next，此时链表为【3】，回到step1 two
    • step7 回到step1 two
      • two head.next = 【3】
      • three head.val == 2? head.next : head
      • return head，此时链表为【1, 3】，回到step1 ，已经执行完了one、two、three，方法返回，结束。

• 递归调用时有代价的：函数调用 + 系统栈空间（记录当前执行位置、变量状态、时间消耗），若不处理基础问题，即没有递归出口，方法执行一直占内存，直到内存占满，或溢出，导致系统over了。一个算法必须总是在有限次的执行后结束，且每一步都能在有限时间内完成。