Algorithm on My Little Blog

Simple Tree Traversal

Thu, 10 Sep 2026 11:21:00 +0000

🖋️ Leaf-Similar Trees (Leetcode 872)

In short, we are gonna to compare the leaves between two tree.

First, we should get the elements from the leaves.

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:

    def dfs(self, root, list_para):
        temp = []
        curr = root

        while curr is not None or len(temp) > 0:
            while curr:
                temp.append(curr)
                curr = curr.left

            // Save all elements on the left side, but
            // we only want the leaf element, so...
            curr = temp.pop()

            if curr.left is None and curr.right is None:
                list_para.append(curr.val)

            curr = curr.right
            // Attention here, we 'move' our 'pointer' to the right side
            // After we have done all the things we should do on the left side

    def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        l1 = []
        l2 = []
        self.dfs(root1, l1)
        self.dfs(root2, l2)
        return l1 == l2

Recursion Method


class Solution:
    def dfs(self, root, list_para):
        if root is None:
            return

        if root.left is None and root.right is None:
            list_para.append(root.val)
        // **Move** to the left, do it again, **until 'root is None'**
        self.dfs(root.left, list_para)
        // Left side finished

        // **Move** to the right, do it again, **until 'root is None'**
        self.dfs(root.right, list_para)
				 // Right side finished, all required data is saved in the list_para

    def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        l1 = []
        l2 = []
        self.dfs(root1, l1)
        self.dfs(root2, l2)
        return l1 == l2

Two Ways to Reverse a Singly Linked List

Thu, 10 Sep 2026 11:20:00 +0000

0. Structure of a Singly Linked List

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

// 1 -> 2 -> 3 -> 4 -> 5 -> NULL

1. Move pointers

def reverseList(head: ListNode) -> ListNode:
    prev = None
    curr = head

    while curr:
        temp = curr.next    # Save next node
        curr.next = prev    # Reverse the pointer
        prev = curr         # Move prev forward
        curr = temp         # Move curr forward

    return prev  # New head of the reversed list

0: 1 -> None 2 -> 3 -> 4 -> 5 -> NULL

1: 2 -> 1 -> None 3 -> 4 -> 5 -> NULL

2: 3 -> 2 -> 1 -> None 4 -> 5 -> NULL

3: 4 -> 3 -> 2 -> 1 -> None 5 -> NULL

4: 5 -> 4 -> 3 -> 2 -> 1 -> None

2. Head Insertion

def reverseList(head: ListNode) -> ListNode:
    prev = ListNode(0)
    prev.next = head
    curr = prev.next

    while curr.next:
        temp = curr.next
        curr.next = temp.next
        temp.next = prev.next
        prev.next = temp

    return prev.next

0: 1 -> 2 -> 3 -> 4 -> 5 -> NULL

1: 2 -> 1 -> 3 -> 4 -> 5 -> NULL

2: 3 -> 2 -> 1 -> 4 -> 5 -> NULL

3: 4 -> 3 -> 2 -> 1 -> 5 -> NULL

4: 5 -> 4 -> 3 -> 2 -> 1 -> NULL

Leetcode reflection (1)

Thu, 10 Sep 2026 11:17:00 +0000

1732. Find the Highest Altitude

There is a biker going on a road trip. The road trip consists of n + 1 points at different altitudes. The biker starts his trip on point 0 with altitude equal 0.

You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i and i + 1 for all (0 <= i < n). Return the highest altitude of a point.

Example 1:

Input: gain = [-5,1,5,0,-7]
Output: 1
Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.

Example 2:

Input: gain = [-4,-3,-2,-1,4,3,2]
Output: 0
Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.

Solution:

A straightforward question, the major solution is to successively sum 2 Adjacent elements in the list, just like the example.

My first answer is:

class Solution:
    def largestAltitude(self, gain: List[int]) -> int:
        for i in range(1, len(gain)):
            gain[i] += gain[i -1]
        fixed = max(gain)
        if fixed > 0:
            return fixed
        else:
            return 0

Then, I found another one which used the python API:

class Solution:
    def largestAltitude(self, gain: List[int]) -> int:
        return max(accumulate(gain, initial =0))

One line, and the space complexity is O(1).

My thought after this question is to use Python APIs (such as accumulate()) as much as I can since it probably has been optimized by someone else. Unless I am not so happy with their performance.

Move Zeroes: Understanding Parameter Behavior in Python

Thu, 10 Sep 2026 11:12:00 +0000

🔔 Prelude: When addressing the “Move Zeroes” problem, it is simple to misinterpret Python’s parameter behavior. Remember: A local variable and a parameter sharing the same name does not mean they refer to the same object.

🖋️ Move Zeroes

Given an integer array nums, move all 0’s to the end of it while maintaining the relative order of the non-zero elements.

Note that you must do this in-place without making a copy of the array.

Example 1:

Input: nums = [0,1,0,3,12]
Output: [1,3,12,0,0]

Here’s an example of solving the “Move Zeroes” problem (a wrong one):

def moveZeroes(self, nums: List[int]) -> None:
    counter = 0
    while 0 in nums:
        nums.remove(0)
        counter += 1
    nums = nums + [0] * counter

In this code, the final assignment to nums actually doesn’t affect the parameter nums because they are different variables.

Within the function, Python creates a new namespace, known as the local scope. All variables defined or assigned inside the function are, by default, considered local variables.

When you execute nums = nums + [0] * counter inside the function, Python’s interpreter assigns the new list object (from the right-hand expression) to the local variable nums. This means:

The original nums (the parameter) still refers to the passed-in list object.
The local variable nums now refers to a new list object.
The assignment nums = ... changes the binding of the local nums to point to the new object, leaving the original passed-in list unaffected.

A possible solution is to change the first nums to nums[:], which means you are modifying the original object.

Two-pointer Solution:

A more efficient approach to solving the “Move Zeroes” problem is using a two-pointer method:

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        left = 0

        for right in range(len(nums)):
            if nums[right] != 0:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1

In this solution, left is initialized to zero, and the first element being zero does not affect the algorithm’s ability to move all zeros to the right. This two-pointer method efficiently processes the list in-place, making it a more optimal solution than the previous approach.