Sword Finger Offer 18.Delete a node from a list of chains

Given the head pointer of a one-way chain table and the value of a node to be deleted, define a function to delete the node.
Returns the head node of the deleted list. The Title guarantees that the values of the nodes in the list are different from each other.

pre and node refer to the previous node and the node to be judged respectively

class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        if head.val == val: return head.next
        pre, node = head, head.next
        while node:
            if node.val==val:
                pre.next = node.next
                node = pre.next
            else:
                pre = node
                node = node.next
        return head

Swordfinger Offer 22.The last k th node in the list of chains

Third to last, k=3
- - - - - - - None
- - - - k - - None
i. - - j. - - - None

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        i = j = head
        for _ in range(k):
            if j:
                j = j.next
            else: return i # k is longer than the list of chains
        while j:
            i=i.next
            j=j.next
        return i

Swordfinger Offer 25.Merge two sorted chains

Enter two incrementally ordered chains, merge the two chains, and leave the nodes in the new chains in incremental order.
My criteria for judgment start with l1 or l2. I generate a header node by referencing the answer, and no extra judgment is required.

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1: return l2
        if not l2: return l1
        if l1.val <= l2.val:
            head = l1
            l1 = l1.next
        else:
            head = l2
            l2 = l2.next
        cur = head
        while l1 and l2:
            if l1.val < l2.val:
                cur.next, l1 = l1, l1.next
            else:
                cur.next, l2 = l2, l2.next
            cur = cur.next
        cur.next = l1 if l1 else l2
        return head

Reference Answer

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        cur = dum = ListNode(0)
        while l1 and l2:
            if l1.val < l2.val:
                cur.next, l1 = l1, l1.next
            else:
                cur.next, l2 = l2, l2.next
            cur = cur.next
        cur.next = l1 if l1 else l2
        return dum.next

Swordfinger Offer 52.First common node of two linked lists

Unexpected, it involves clever mathematical calculations, similar to the ring entrance found below.

Explanation: Here the last None is also considered a node

The two lists are L1+C, L2+C respectively. C is the length of the public part. According to the landowner's practice: the first person takes L1+C step, then returns to the starting point of the second person to take L2 step; the second person takes L2+C step, then returns to the starting point of the first person to take L1 step. When both people walk L1+L2+C, they meet.

In disjoint cases, set the A-list length to be a B-list length, b-last a+b = b+a, so it must go to None together. It can be understood that both chains end up pointing to the same null (None) node, instead of the special case of disjoint. Very clever.

Instead of
node1 = node1.next if node1.next else headB

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        node1, node2 = headA, headB

        while node1 != node2:
            node1 = node1.next if node1 else headB # When node1 goes to the None node of A, it goes to B next
            node2 = node2.next if node2 else headA
        # When A and B are equal in length, the result is known the first time
        return node1

leetcode142.Ring Chain Table II

https://leetcode-cn.com/problems/linked-list-cycle-ii/
Given a list of chains, returns the first node at which the list begins to ring. If the list is not ring, returns null.

To represent rings in a given chain table, we use the integer pos to represent the position where the end of the chain is connected to the chain table (the index starts at 0). If pos is -1, there are no rings in the chain table. Note that pos is only used to identify rings and is not passed as a parameter to the function.

Summary:
f=2s (2 steps per fast pointer, exactly twice the distance)
f = s + nb (when we met, we just made a lot of n laps)
Launch 1.First encounter, slow = nb
2.Walk from the head node to the entry ring: a + nb
3.And slow has already moved nb, so slow's next step a is the point of entry.
4.From 3, start distance entrance = first encounter location + a

How do you know that slow has just taken step a? Start with the head and walk with the slow pointer, and it happens to be step a when you meet

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast, slow = head, head
        while True:
            if not (fast and fast.next): return None
            fast, slow = fast.next.next, slow.next
            if fast == slow: break
        fast = head
        while fast != slow:
            fast, slow = fast.next, slow.next
        return fast

Sword Finger Offer 21.Adjust the order of arrays so that odd numbers precede even numbers

Enter an integer array and implement a function to adjust the order of the numbers in the array so that all odd numbers are in the first half of the array and all even numbers are in the second half.

The x&1 bit operation is equivalent to the x% 2x%2 redundancy operation, that is, it can be used to determine the parity of numbers.

class Solution:
    def exchange(self, nums: List[int]) -> List[int]:
        i, j = 0, len(nums)-1
        while i<j: # Maybe it doesn't happen here i==j
            while i<j: # Can't equal, when i==j it ends
                if nums[i]%2==1: i+=1
                else: break
            while j>i:
                if nums[j]%2==0: j-=1
                else: break
            if i!=j:
                tmp = nums[i] 
                nums[i] = nums[j]
                nums[j] = tmp

        return nums
        
class Solution:
    def exchange(self, nums: List[int]) -> List[int]:
        i, j = 0, len(nums) - 1
        while i < j:
            while i < j and nums[i] & 1 == 1: i += 1
            while i < j and nums[j] & 1 == 0: j -= 1
            nums[i], nums[j] = nums[j], nums[i]
        return nums

Swordfinger Offer 57.And two numbers for s

Enter an incrementally ordered array and a number s, and look for two numbers in the array so that their sum is exactly s. If the sum of more than one number equals s s s, then output any pair.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        i, j = 0, len(nums) - 1
        while i < j:
            s = nums[i] + nums[j]
            if s > target: j -= 1
            elif s < target: i += 1
            else: return nums[i], nums[j]
        return []

Swordfinger Offer 58 - I. Flip word order

Enter an English sentence and flip the order of the words in the sentence, but the order of the characters within the word does not change. For simplicity, punctuation is handled as normal letters. For example, enter the string "I am a student." "then output" student. a am I."

There are two details to deal with

The difference between split() and split('') in python

Method 1:
Using the built-in functions of String Split and List Reverse (not recommended for interviews), string flip requirements for this topic can be easily implemented.

class Solution:
    def reverseWords(self, s: str) -> str:
        s = s.strip() # Remove first and last spaces
        strs = s.split() # Split String
        strs.reverse() # Flip Word List # [: -1] is also in reverse order
        return ' '.join(strs) # Stitch into strings and return

Method 2: Double pointer, in words, to find each word as a list element

class Solution:
    def reverseWords(self, s: str) -> str:
        s = s.strip() # Remove first and last spaces
        i = j = len(s) - 1
        res = []
        while i >= 0:
            while i >= 0 and s[i] != ' ': i -= 1 # Search for first space
            res.append(s[i + 1: j + 1]) # Add Word
            while s[i] == ' ': i -= 1 # Skip space between words # i=-1 is actually the last
            j = i # j Final character pointing to the next word
        return ' '.join(res) # Stitch and return