## subject

If a linked list contains a ring, the first node entering the ring from the chain header node in the direction of the next pointer is the ring entry node.

Now that the head node head is known, locate the entry node.

Idea:

Differential method - make n turns when the fast and slow pointers meet. Adjust the starting position so that they just meet at the entrance node.

Steps:

1. Locate the "meeting point" - the fast and slow pointer starts from the beginning at the same time to locate the ring meeting point (this action can also be used to judge whether the linked list has a ring and return a node in the ring, which is very useful!)

2.P1 starts from the head node, P2 starts from the meeting point, and then meets again, which is the entry node

Example (from q22 in Chapter 4 of sword finger Offer):

Given the pointer of the chain header node in the figure, the returned content should be the pointer of entry node 3

First create the example list:

'''Define linked list nodes''' class ListNode(): def __init__(self, item): self.item = item self.next = None '''Create sample linked list''' arr = [1,2,3,4,5,6] n = len(arr) head = ListNode(arr[0]) cur = head for i in range(1,n): node = ListNode(arr[i]) cur.next = node cur = cur.next '''Connect the ring''' tail = head for i in range(0,5): tail = tail.next entry = head for i in range(0,2): entry = entry.next tail.next = entry

After creating it, check the contents of the linked list to see if it is connected correctly

'''Check circular linked list''' arr_check = [] cur = head tag = 0 while(cur != None)&(tag<15): arr_check.append(cur.item) cur = cur.next tag+=1 print(arr_check)

The result output is as follows (cyclic output from the position of the ring, i.e. 1 2 3 4 5 6 - > 3 4 5 6 - > 3 4 5 6 - > 3...):

[1, 2, 3, 4, 5, 6, 3, 4, 5, 6, 3, 4, 5, 6, 3]

### Implement search

The solution class contains two functions:

-locateMeetNode() is responsible for finding the "encounter node" and judging whether the linked list has a ring

-findEntry() is responsible for pushing out the entry node by using the encounter node

class Solution(): '''Step 1 locate meet node - fast vs slow''' def locateMeetNode(self, head: ListNode) -> ListNode: if (head == None)|(head.next == None): print('List chain not exist or contains 1 node only.') return None else: slow = head.next fast = slow.next while(fast != None)&(slow != None): if(fast == slow): return slow slow = slow.next fast = fast.next if(fast != None): fast = fast.next '''if the loop ends without returning anything, then there is no circle in list chain''' print('This list chain contains no circle.') return None '''Step 2 start from meet node - meet again''' def findEntry(self, head: ListNode) -> ListNode: p1 = head p2 = self.locateMeetNode(head) if(p2 == None): print('No entry because there is no circle.') return None while(p1 != p2): p1 = p1.next p2 = p2.next return p1

### Test code:

1. Check whether the meeting point is correct. According to the linked list of this question, it should be 5

s1 = Solution() meet = s1.locateMeetNode(head) meet.item

Result output: 5

2. Check whether the entry node is correct. According to the linked list, it should be 3

entry = s1.findEntry(h1) entry.item

Result output: 3

### Reflection: stuck place

1. Instantiation of solution class s1=Solution() takes 15 minutes to find the reason and try to reconstruct the function for 15 minutes, which is about half an hour in total

2. Extreme cases that must be considered when using the double pointer method: head = = None, head Next = = None returns None directly

3. Double pointer loop loop control sequence: first compare the pointers, then walk, and then fast needle empty check + 1 step

4. Careless problem: typo writes the starting point of the fast pointer incorrectly, resulting in debugging for 10 minutes

In the follow-up practice, we should continue to consolidate the foundation and prevent careless problems, so as to reduce the debug time.