算法学习之删除链表中重复的结点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

方法一：遍历先把重复的节点存储待HashSet，然后遍历按照先检查头部分重复情况并删除，在检查中后部重复并删除。

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
import java.util.*;
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
     if(pHead==null||pHead.next==null){
         return pHead;
     } 
     
     ListNode pre = pHead;
     ListNode next = pre.next;
     HashSet set = new HashSet();   
     while(next!=null){ // 重复点加入到HashSet
           if(pre.val==next.val){
             set.add(pre.val);  
           }
           pre = next;
           next = next.next;
     }
     // 删除头部重复情况的元素并把头指针后移。
     while(pHead!=null&&set.contains(pHead.val)){ 
           pHead = pHead.next;
     }
     if(pHead==null){
         return null;
     }  
     // 再删除中后部分重复部分，头指针不变。 
     pre = pHead;
     next = pHead.next;
     while(next!=null){
         if(set.contains(next.val)){
            pre.next = next.next; 
            next =  next.next;
         }else{
            pre = pre.next;
            next = next.next; 
         }
     }   
     return pHead;   
    }
}

时间复杂度：HashSet的查找为O(1)，外层遍历为n，所以时间复杂度为O(n);

空间复杂度：最好的情况为没用重复O(1),最差的情况为全重复O(n/2);

方法二：一边遍历一遍删除。

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
import java.util.*;
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null||pHead.next==null){
            return pHead;
        }
        ListNode head = new ListNode(Integer.MIN_VALUE);// 自主构建head,为记录头指针
        head.next = pHead;
        ListNode pre = head;
        ListNode cur = pre.next;
        while(cur!=null){
            if(cur.next!=null&&cur.val==cur.next.val){
                // 当值重复时持续去除
                while(cur.next!=null&&cur.val==cur.next.val){
                      cur = cur.next;
                }
                // 去除重复值后指针仍停留在最后一个重复值中的最后一个重复值位置，所以进行切换到下一位查找是否还有其他不同的的重复组。
                cur = cur.next;
                pre.next = cur;
            }else{
                pre = cur;
                cur = cur.next;
            }
        }
      return head.next;  
    }
}

时间复杂度：O(n)；

空间复杂度：O(1)；

练习地址：https://www.nowcoder.com/practice/fc533c45b73a41b0b44ccba763f866ef

 

题目二：在O(1)时间内删除链表节点。
给定单向链表的头指针和一个节点指针，定义一个函数在O(1)时间内删除该节点。

思路：很简单，直接上代码

class ListNode {
    int value;
    ListNode next;
}
// 主体思路：
// 不是未节点的时候，直接使用toBeDeleted的next节点覆盖toBeDeleted节点即可
// 是末节点，则直接去除尾结点
public void deleteNode(ListNode head, ListNode toBeDeleted) {
    if (head == null || toBeDeleted == null) {
        return;
    }
    if (toBeDeleted.next != null) {
       
        ListNode pNext = toBeDeleted.next;
        toBeDeleted.value = pNext.value;
        toBeDeleted.next = pNext.next;
        pNext = null;
    } else if (head == toBeDeleted) {
        
        head = null;
        toBeDeleted = null;
    } else {
        // 此处tem与head两个不同对象
        ListNode tem = head;
        while (tem.next.next != null) {
            tem = tem.next;
        }
        tem.next = null;
        toBeDeleted = null;
    }
}

时间空间复杂度都：O(1)