删除有序链表中的重复节点II

Remove Duplicates from sorted list II

​ #算法每日一题#

今天的每日一题，它的题目描述是这样的：

Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. Return the linked list sorted as well.

• 解法一

  ​ 题目给出了一个排好序的链表，要求我们删除其中有重复的所有节点，只保留无重复的数字。这道题看起来好像很简单的样子，节点的值是-100~100之间的整数，而且链表是从小到大排好序的，也就是说重复的数字一定是相邻的，那这不是很容易求解吗？直接遍历链表的各个节点，如果一个节点的后一个节点与该节点发生了重复，那么我们就往后遍历所有与该节点重复的节点，直接让这个节点的前一个节点指向最后一个重复节点的next节点，这样就完成了对所有重复节点的删除。

  ​ 好，就按照这个思路来试一试。

  ​ 首先，因为链表的头结点也有可能会重复，所以头结点可能会被删掉。这里我们使用一个常用的技巧：dumy节点，也叫哑结点。使dummy.next = head, 这样即使head被删了，那么操作dummy.next指向新的头结点，最终返回头结点时只需返回dummy.next即可。

  ​ 该算法的时间复杂度为O(n)

  ​ 我是用Java实现的这个算法，实现代码如下：

  ListNode.java

  public class ListNode {
      int val;
      ListNode next;
      ListNode() {}
      ListNode(int val) {this.val = val;}
      ListNode(int val, ListNode next) {this.val = val; this.next = next;}
  }
  

  Solution.java

public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) {
            return head;
        }

        ListNode dummy = new ListNode(0, head);

        ListNode cur = dummy;
        while(cur.next != null && cur.next.next != null) {
            if(cur.next.val == cur.next.next.val) {
                int x = cur.next.val;
                while(cur.next != null && cur.next.val == x) {
                    cur.next = cur.next.next;
                }
            }
            else {
                cur = cur.next;
            }
        }

        return dummy.next;
    }
}

此解法的提交结果为

• 解法二

  仔细读此题，发现这道题目也可以使用递归的思想来解决。

  • 递归函数我们就使用deleteDuplicates(head)， 它的含义是删除以head为头结点的链表中重复的节点。
  • 递归终止条件
    • 如果head为空，那么肯定没有重复节点，返回head；
    • 如果head.next为空，说明链表中只有一个节点，那也不会出现重复节点，也直接返回head。
  • 什么时候需要进行递归呢？有如下两种情况
    • 如果head.val != head.next.val， 说明头结点的值不等于下一个节点的值，所以当前head节点需要保留下来；但是head.next节点要不要保留我们还不知道，需要对head.next进行递归，即去除以head.next为头结点的链表的重复节点。所以head.next = deleteDuplicates(head.next)
    • 如果head.val == head.next.val， 说明头结点的值等于下一个节点的值， 所以当前的head节点需要删除掉；但是head.next节点要不要删除我们还不知道， 需要一直向后遍历寻找到与head.val不相等的节点。用一个节点p，向后遍历到与head.val不相等的节点，返回deleteDuplicates§

  由以上思路我们得出以下代码：

  public class Solution2 {
      public ListNode deleteDuplicates(ListNode head) {
          if(head == null || head.next == null) {
              return head;
          }
  
          if(head.val != head.next.val) {
              head.next = deleteDuplicates(head.next);
          }
          else {
              ListNode p =head.next;
              while(p != null && head.val == p.val) {
                  p = p.next;
              }
              return deleteDuplicates(p);
          }
  
          return head;
      }
  }
  

  这一种解法的提交结果为：

这两种解法，时间复杂度和空间复杂度其实没有相差多少，但是两种方法为我们提供了不同的解题思想。