ListNode *deleteDuplicates(ListNode *head) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    ListNode *p=head,*q;
    if (p == NULL || p->next == NULL) return p;
    q = p->next;
    // invariant: no duplication in range [head, p] && q == p->next
    while (q != NULL)  // reach the end, loop terminates
    {
        if (q->val != p->val)   
        {
            // find a new val, advance p to the next, new [head,p] has no duplicates.
            p=p->next;  
            // make sure q==p->next, and move closer to loop end
            q=q->next;
        }
        else
        {
            // find duplicated value, range [head,p] is not changed.
            ListNode *t=q;
            // advance q to move closer to loop end, make sure q == p->next
            q=q->next;
            p->next = q;            
            // avoid memory leak.
            delete t;
        }

    }
    return head;

}

ListNode deleteDuplicates(ListNode head) {

    if(!head) return NULL;
    ListNode *prev = head, *cur = head;        
    while(cur->next) {
        cur = cur->next;            
        if(prev->val==cur->val) {
            prev->next = cur->next;
            delete cur;
            cur = prev;                
        }    
        else 
            prev = cur;            
    }
    return head;
}

};

class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (!head) return NULL;
        ListNode *pre = head, *cur = head->next;
        while (cur) {
            if (cur->val == pre->val) {
                pre->next = cur->next;
                delete cur;
                cur = pre;
            }
            pre = cur;
            cur = cur->next;
        }

        return head;
    }
};

public ListNode deleteDuplicates(ListNode head) {
    ListNode root = new ListNode(-1);
    ListNode last = root, cur_node = head;
    while (cur_node != null) {
        ListNode next_node = cur_node.next;
        while (next_node != null && next_node.val == cur_node.val) {
            next_node = next_node.next;
        }
        last.next = cur_node;
        last = cur_node;
        last.next = null;
        cur_node = next_node;
    }
    return root.next;
}

if( !head) return NULL;
ListNode * cur = head;
ListNode * nxt = head->next;
while( nxt)
{
    if( cur->val == nxt->val)
        {
            ListNode *tmp = nxt;
            cur->next = nxt->next;
            nxt = cur->next;
            delete tmp;
        }
    else
        {
            cur = nxt;
            nxt = nxt->next;
        }
}
return head;

class Solution {
public:
ListNode *deleteDuplicates(ListNode *head) {
if(!head)
    return NULL;
ListNode* pRead = head->next;
ListNode* pWrite = head;
while (pRead)
{
    while (pRead && pRead->val == pWrite->val)
        pRead = pRead->next;
    pWrite->next = pRead;
    pWrite = pRead;
}
return head;
}
};

public class Solution {
public ListNode deleteDuplicates(ListNode head) {
    // Start typing your Java solution below
    // DO NOT write main() function
    if (head==null) return head;
    ListNode curr = head.next;
    ListNode prev = head;
    while (curr != null) {
        while ((curr != null) && (curr.val == prev.val) ) {
            curr = curr.next;
        }
        prev.next = curr;
        if (curr == null) break;
        prev = prev.next;
        curr = curr.next;
    }
    return head;
}
}

ListNode *deleteDuplicates(ListNode *head) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    if(!head)
        return head;
    if(!head->next)
        return head;

    ListNode *curr = head->next, *pre = head;

    while(curr) {

        if(curr->val == pre->val) {
            ListNode *rem = curr;
            pre->next = curr->next;
            curr = pre->next;
            delete rem;
        }
        else {
            pre = curr;
            curr = curr->next;
        }
    }
    return head;
}

public class Solution {
public ListNode deleteDuplicates(ListNode head) {
    // Start typing your Java solution below
    // DO NOT write main() function
    if(head==null) return head;
    ListNode prev=head;
    ListNode cur=head.next;

    while(cur!=null){
        if(cur.val!=prev.val) prev=prev.next;
        cur=cur.next;
        prev.next=cur;
    }
    return head;
}

}

ListNode *deleteDuplicates(ListNode *head) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    if (!head || !head->next) {
        return head;
    }

    ListNode *hd, *nx;
    hd = head;
    nx = hd->next;

    for (; nx != NULL;nx = nx->next) {
        if (hd->val == nx->val) {
            hd->next = nx->next;
        } else {
            hd = hd->next;
        }
    }

    return head;
}