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

题目描述

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

解题思路

先构建好测试样例，比如 1 1 1 2 2 3， 1 1 2 2 3 3，1 2 3 3 4等等，终于写出了非递归的版本，非常喜欢评论区里递归的版本，mark

Code

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    void deleteListNode(ListNode* pStart, ListNode* pEnd) {
        if(!pStart) return ;
        ListNode* pNode = pStart;
        while(pNode != pEnd) {
            ListNode* pTemp = pNode;
            pNode = pNode->next;
            delete pTemp;
            pTemp = nullptr;
        }
        
    }
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(!pHead) return pHead;
        ListNode *pre = pHead, *pNode = pHead;
        while(pNode && pNode->next) {
            pre = pNode;
            pNode = pNode->next;
            if(pre->val == pNode->val) {
                pNode = pre;
            }
            ListNode* pNext = pNode->next;
            while(pNext && pNext->val == pNode->val) {
                pNext = pNext->next;
            }
            if(pNext != pNode->next) {
                if(pre == pNode) {
                    pre = pHead = pNext;
                } else {
                    pre->next = pNext;
                }
                deleteListNode(pNode, pNext);
                pNode = pre;
            }
        }
        return pHead;
    }
};

• java 递归

/*
 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 pNode = pHead.next;
        if(pNode != null &&  pNode.val == pHead.val) {
            while(pNode != null && pNode.val == pHead.val) {
                pNode = pNode.next;
            }
            return deleteDuplication(pNode);
        }
        pHead.next = deleteDuplication(pNode);
        return pHead;
    }
}

• java非递归

/*
 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 cur = pHead, pre = null;
        while(cur != null) {
            ListNode pNode = cur.next;
            if(pNode != null &&  pNode.val == cur.val) {
                while(pNode != null && pNode.val == cur.val) {
                    pNode = pNode.next;
                }
                cur = pNode;
                continue;
            } 
            if(pre == null) {
                pHead = cur;
            } else {
                pre.next = cur;
            }
            pre = cur;
            cur = cur.next;
        }
        if(pre != null) pre.next = null;
        return pre == null ? pre : pHead;
    }
}

• java非递归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;
        ListNode pNode = pHead, result = null, pre = null;
        while(pNode != null) {
            if(pNode.next != null && pNode.next.val == pNode.val) {
                while(pNode.next != null && pNode.next.val == pNode.val) {
                    pNode = pNode.next;
                }
            } else {
                if(pre == null) {
                    pre = result = pNode;
                } else {
                    pre.next = pNode;
                    pre = pNode;
                }
            }
            pNode = pNode.next;
        }
        if(pre != null) pre.next = null;
        return result;
    }
}

• 评论区递归的版本

//链接：https://www.nowcoder.com/questionTerminal/fc533c45b73a41b0b44ccba763f866ef
//来源：牛客网

//递归
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if (pHead==NULL)
            return NULL;
        if (pHead!=NULL && pHead->next==NULL)
            return pHead;
                 
        ListNode* current;
         
        if ( pHead->next->val==pHead->val){
            current=pHead->next->next;
            while (current != NULL && current->val==pHead->val)
                current=current->next;
            return deleteDuplication(current);                     
        }
         
        else {
            current=pHead->next;
            pHead->next=deleteDuplication(current);
            return pHead;
        }    
    }
};