剑指OFFER笔记_18_2_删除链表中重复的节点_JAVA实现

题目：删除链表中重复的节点

• 给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

解题思路

• 此题需要将所有重复的数字都删除，而不是将重复的数字删除至只有一个。情况相对会复杂一点。
• 若链表为[1,2,2,3,3,3,4]，需要让1直接指向4，所以需要一个ListNode保存1，一个ListNode保存4。
• 遇到重复的数字，将数字保存，往后检索直到值不等于该数字。
• 由于需要返回一个ListNode，所以需要一个headNode来保存结果的头节点。

代码

ListNode结构代码

package q18_02;

public class ListNode {
    public int val;
    public ListNode next;
    public ListNode(int x) {
        val = x;
    }
}

函数主体部分代码

package q18_02;

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

        ListNode curNode = head;
        ListNode preNode = null;
        ListNode headNode = null;   //需要返回一个头节点
        boolean getHead = false;

        //当前节点不为空
        while(curNode != null)
        {
            ListNode nextNode = curNode.next;
            boolean deleteFlag = false;

            if (nextNode != null && nextNode.val == curNode.val)
            {
                //当nextNode不为空且值与curNode相等时，需要执行删除操作。
                deleteFlag = true;
                if (headNode != null && nextNode.val == headNode.val)   //此时的headNode作废
                {
                    headNode = null;
                    getHead = false;
                }
            }

            if (deleteFlag == false)
            {
                //若不需要删除操作，则将preNode赋值，curNode前进
                preNode = curNode;
                if (!getHead)
                {
                    headNode = curNode;
                    getHead = true;
                }
                curNode = curNode.next;
            }else
            {
                //若需要删除操作，则需要删除之后所有和当前curNode值相同的节点
                int deleteValue = curNode.val;
                ListNode nodeToDel = curNode;

                //当nodeToDel为空节点，或者值不等于deleteValue时，结束循环
                //此时nodeToDel要么是空节点，要么是下一个不同值的节点
                while (nodeToDel != null && nodeToDel.val == deleteValue)
                {
                    nodeToDel = nodeToDel.next;
                }
                nextNode = nodeToDel;
                //若还没有找到开头preNode
                if (preNode == null)
                {
                    preNode = nextNode;

                    headNode = preNode;
                    getHead = true;
                }
                //否则preNode.next指向nextNode,跳过重复元素
                else
                {
                    preNode.next = nextNode;
                }
                curNode = nextNode;
            }
        }
        if (headNode == null)
        {
            return null;
        }
        return headNode;
    }

    public void printList(ListNode head)
    {
        if (head == null)
        {
            return;
        }
        ListNode pnode = head;
        while(pnode != null)
        {
            System.out.print(pnode.val + " ");
            pnode = pnode.next;
        }
        System.out.println();
    }
}

测试部分代码

package q18_02;

public class TestApp {
    public static void main(String[] args) {
        ListNode pHead = new ListNode(1);
        pHead.next = new ListNode(1);
        pHead.next.next = new ListNode(2);
        pHead.next.next.next = new ListNode(2);
        pHead.next.next.next.next = new ListNode(3);
        pHead.next.next.next.next.next = new ListNode(3);
        pHead.next.next.next.next.next.next = new ListNode(4);
        Solution s = new Solution();
        s.printList(pHead);
        s.printList(s.deleteDuplicates(pHead));
    }
}

运行结果截图

LeetCode运行截图