20190602-剑指offer23-AcWing-34. 链表中环的入口结点

剑指offer23-AcWing-34. 链表中环的入口结点

给定一个链表，若其中包含环，则输出环的入口节点。
若其中不包含环，则输出null。
样例
给定如上所示的链表,3和6之间有环：
[1, 2, 3, 4, 5, 6]
2
注意，这里的2表示编号是2的节点，节点编号从0开始。所以编号是2的节点就是val等于3的节点。
则输出环的入口节点3.

思路：
    初试两个结点，一个fastNode，每次移动两个结点，一个slowNode，每次移动一个结点；两个结点同时出发，直到两个结点重合。然后初试一个resNode指向头结点，每次移动一个结点，和slowNode一起同时移动，直到resNode和slowNode重合，重合指向的结点即为环入口结点。
C++ code：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *entryNodeOfLoop(ListNode *head) {
        if(head == NULL){
            return head;
        }
        ListNode* resNode = head;
        ListNode* slowNode = head->next;
        if(slowNode == NULL){
            return NULL;
        }
        ListNode* fastNode = head->next->next;
        if(fastNode == NULL){
            return NULL;
        }
        while(fastNode != slowNode){
            if(fastNode->next == NULL || fastNode->next->next == NULL){
                return NULL;
            }
            fastNode = fastNode->next->next;
            slowNode = slowNode->next;
        }

        while(resNode != slowNode){
            resNode = resNode->next;
            slowNode = slowNode->next;
        }
        return resNode;
    }
};

python code:

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def entryNodeOfLoop(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None:
            return None
        resNode = head
        slowNode = head.next
        if slowNode == None:
            return None
        fastNode = slowNode.next
        if fastNode == None:
            return None
            
        while fastNode != slowNode:
            if fastNode.next == None or fastNode.next.next == None:
                return None
            fastNode = fastNode.next.next
            slowNode = slowNode.next
        
        while resNode != slowNode:
            resNode = resNode.next
            slowNode = slowNode.next
        
        return resNode