When takling algorithm problems, visualizing the flow of code can significantly enhance understanding. Python Tutor is a tool for visualizing code like python, c++, java, etc. It can offer insights into how variables change, how data structures evolve, and how control flows through loops and recursive calls. However, there are some limitation when you implement the code.

Java

• Leecode Problem 78. Subsets Solution

Java limitations

• base on the description in java limitations, Java Collections data structures like ArrayList and LinkedList aren't visualized.

Replace ArrayList to Array for visualization

code snippet

import java.util.List;

public class MainClass {
  public static int[][] subsets(int[] nums) {
      int[][] result = new int[1][0];
      for (int n : nums) {
          int size = result.length;
          int[][] newResult = new int[size * 2][]; // Double the size to accommodate new subsets
          System.arraycopy(result, 0, newResult, 0, size);
          for (int i = 0; i < size; i++) {
              int[] subset = new int[result[i].length + 1];
              System.arraycopy(result[i], 0, subset, 0, result[i].length);
              subset[subset.length - 1] = n;
              newResult[size + i] = subset;
          }
          result = newResult;
      }
      return result;
  }
  
  public static void main(String[] args) {
    int[] nums = {1, 2, 3};
    System.out.println(subsets(nums));
  }
}

Python

• LeetCode 206. Reverse Linked List

from typing import Optional  # <- import package

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None
        cur = head
        
        while cur:
            n = cur.next
            cur.next = prev
            prev = cur
            cur = n
            
        return prev

# Create Helper function to print the list (for output visualization purpose)
def print_list(head: Optional[ListNode]):
    cur = head
    result = []
    while cur:
        result.append(cur.val)
        cur = cur.next
    print(result)
    
# Creating ListNode list of the problem: 1 -> 2 -> 3 -> 4 -> 5
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)

solution = Solution()
reversed_head = solution.reverseList(head)

# Print the reversed list
print_list(reversed_head)

226. Invert Binary Tree

from typing import Optional
import collections

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None

        queue = collections.deque([root])
        while queue:
            current = queue.popleft()
            current.left, current.right = current.right, current.left

            if current.left:
                queue.append(current.left)

            if current.right:
                queue.append(current.right)
        
        return root

# root = [4,2,7,1,3,6,9]
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(7)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)

sol = Solution()
sol.invertTree(root)