[leet code] Remove Duplicates from Sorted List II

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

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

====================

Linked list problems are strait forward as long as we draw the examples before coding.  From the example of 1->2->3->3->4->4->5, if we can examine the list node one by one, we can find that only the node with value != its previous node and next node would be exist in the resulting link list.  According to this idea, we can set up 3 pointers, one pointer is for the resting linked list, the other two are for the node value compare (i.e. compare the current node value with its previous node and next node).  

Note that Pointer of resulting link list will be move only when the distinct number found.  While the current node pointer and its previous node pointer right shift 1 step in each iteration.

Now we have the main algorithm, but we also need to consider the special cases: case of current node is head of the linked list, and the case that current node is the end of the link list.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next==null) return head;
        
        ListNode fakeHead = new ListNode(0); // for resulting linked list returning
        fakeHead.next = head;
        
        ListNode rsNode = fakeHead; // pointer of resulting linked list
        ListNode preNode = null; // pointer of previous node
        ListNode currNode = head; // pointer of current node

        
        while(currNode != null){
            if (currNode == head){ // 1st node case
                if(currNode.val!= currNode.next.val){ 
                    rsNode.next = currNode;
                    rsNode=rsNode.next;
                }
            }
            else {  // non 1st node
                if(currNode.next == null){// last node case
                    if(preNode.val != currNode.val) rsNode.next = currNode;
                    else rsNode.next = null;// don't forget!!
                }
                else{ // non 1st or last node
                    if(preNode.val!=currNode.val && currNode.val!=currNode.next.val) {// distinct node
                        rsNode.next = currNode;
                        rsNode = rsNode.next;
                    }
                }
            }
            preNode = currNode;
            currNode = currNode.next;
        }
        return fakeHead.next;
    }
}