剑指offer——删除链表中重复的结点

剑指offer——删除链表中重复的结点

题目描述

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

我的解答：分情况讨论，非递归

1. 情况一：从头结点一直走到不含重复结点的节点处。即找到第一个pHead.val!=pHead.next.val的结点，记该节点为头结点，最后是要返回的结点！
2. 情况二：依次删除中间重复结点。该中情况中可以添加一个头结点，以便找到前驱节点，防止断链！

源码如下：（有一些啰嗦）

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

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null || pHead.next==null){
            return pHead;
        }
        while(pHead.val==pHead.next.val){
            ListNode p=pHead.next;
            while(p!=null && p.val==pHead.val){
                p=p.next;
            }
            pHead=p;
            if(pHead==null || pHead.next==null){
                return pHead;
            }//千万注意该情况，否则容易出现空指针异常！改了好久才发现
        }
        ListNode p1=pHead;
        ListNode pre=new ListNode(0);
        pre.next=pHead;
        while(p1!=null && p1.next!=null){
            if(p1.val!=p1.next.val){
                pre=p1;
                p1=p1.next;
            }else{
                ListNode node=p1.next;
                while(node!=null && node.val==p1.val){
                    node=node.next;
                }
                p1=node;
                pre.next=p1;
            }
        }
        return pHead;
    }
}

需要注意的点：一定要注意空指针异常！！！

简化源码如下：

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

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null || pHead.next==null){
            return pHead;
        }
        ListNode head=new ListNode(0);
        head.next=pHead;
        ListNode node=head;
        ListNode p=pHead;
        while(p!=null && p.next!=null){
            if(p.val==p.next.val){
                int val=p.val;
                while(p!=null && p.val==val){
                    p=p.next;
                }
                node.next=p;
            }else{
                node=p;
                p=p.next;
            }
        }
        return head.next;
    }
}

参考其它解答：利用递归

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

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null || pHead.next==null){// 只有0个或1个结点，直接返回
            return pHead;
        }
        if(pHead.val==pHead.next.val){// 当前结点是重复结点
            ListNode node=pHead.next;
            while(node!=null && node.val==pHead.val){
                // 跳过值与当前结点相同的全部结点,找到第一个与当前结点不同的结点
                node=node.next;
            }
            return deleteDuplication(node);// 从第一个与当前结点不同的结点开始递归
        }else{// 当前结点不是重复结点
            pHead.next=deleteDuplication(pHead.next);// 保留当前结点，从下一个结点开始递归
            return pHead;
        }
    }
}