Unit 6: Trees

Return the height of a binary tree and define the result for an empty tree.

Check whether every node respects a valid lower and upper bound, not just its immediate children.

Given two nodes in a binary tree, find the lowest node that has both nodes in its subtrees.

Convert a tree to a string and rebuild it while preserving missing children.

Reconstruct a binary tree from preorder and inorder traversal arrays.

Determine whether any root-to-leaf path has a target sum.

Collect every root-to-leaf path while adding and removing values from a path list.

Find the largest sum of any path in a tree and explain what value each recursive call returns to its parent.

Return both height and balance status so the algorithm does not recompute heights repeatedly.

Swap left and right subtrees at every node and trace the result on a small example.

Return tree values grouped by depth using a queue.

Use breadth-first traversal to report the last visible node at each level.

Use the sorted order of inorder traversal to find the kth smallest value in a BST.

Delete a value from a BST and handle leaf, one-child, and two-child cases.

Find the next larger value after a given value using tree structure rather than sorting all nodes.

Build a height-balanced BST by choosing middle elements recursively.

Rearrange a tree into a single right-child chain following preorder order.

Use the shape of a complete binary tree to count nodes faster than visiting every node when possible.

Determine whether one tree appears inside another using recursive equality checks.

Compute the longest path between any two nodes using heights from subtrees.

Evaluate a tree where leaves are numbers and internal nodes are operators.

Assign horizontal positions to nodes and group values by column.

Find two swapped nodes in a BST by looking for order violations during inorder traversal.

Remove nodes outside a value range while preserving valid BST structure.

Compute the sum of values on the deepest level of a binary tree.

Model folders and files as a tree and search for names matching a condition.

Given a simple decision tree, trace how an input record reaches a final classification.

Explain when a balanced BST gives an advantage over a sorted ArrayList and when it does not.

Given code that accidentally drops a subtree, identify the assignment order that causes the loss.

Create a tree assignment requiring diagrams, recursive implementation, traversal tests, and runtime explanation.