剑指offer 55、56：链表中环的入口结点 、删除链表中重复的结点

55.题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead==NULL)
            return NULL;
        ListNode* p1=pHead;
        ListNode* p2=pHead;
        while(p1->next!=NULL &&p2->next != NULL && p2->next->next != NULL)
        {
            p1=p1->next;
            p2=p2->next->next;
            if(p1==p2)
            {
                p2=pHead;
                while(p1!=p2)
                {
                    p1=p1->next;
                    p2=p2->next;
                }
                return p2;
            }
        }
        return NULL;
    }
};
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        if pHead==None:
            return None
        p1=pHead
        p2=pHead
        while p1.next != None and p2.next!=None and p2.next.next!=None:
            p1=p1.next
            p2=p2.next.next
            if p1==p2:
                p2=pHead
                while p1!=p2:
                    p1=p1.next
                    p2=p2.next
                return p2
        return None
        # write code here

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

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead==NULL || pHead->next ==NULL)
            return pHead;
        ListNode* first= new ListNode(-1);
        ListNode* last=first;
        ListNode* node= pHead;
        last->next=node;//先提前走一步，为了能最终以NULL结尾
        while(node != NULL && node->next != NULL)
        {
            if(node->val==node->next->val)
            {
                int data=node->val;
                while(node != NULL && data==node->val)
                {
                    ListNode* temp=node;
                    node=node->next;
                    delete temp;
                    temp=NULL;
                }
                last->next=node;
            }
            else
            {
                last=last->next;
                node=node->next;
                last->next=node;//为了最后的NULL；
            }
        }
        return first->next;
    }
};

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, pHead):
        if pHead==None or pHead.next==None:
            return pHead
        head=ListNode(-1)
        p=head
        node=pHead
        p.next=node
        while node !=None and node.next !=None:
            if node.val ==node.next.val:
                data=node.val
                while node != None and data==node.val:
                    node=node.next
                p.next=node
            else:
                p=p.next
                node=node.next
                p.next=node
        return head.next
        # write code here