[LeetCode 988] Smallest String Starting From Leaf

Given the root of a binary tree, each node has a value from 0 to 25 representing the letters 'a' to 'z': a value of 0 represents 'a', a value of 1 represents 'b', and so on.

Find the lexicographically smallest string that starts at a leaf of this tree and ends at the root.

(As a reminder, any shorter prefix of a string is lexicographically smaller: for example, "ab" is lexicographically smaller than "aba".  A leaf of a node is a node that has no children.)

Example 1:

Input: [0,1,2,3,4,3,4]
Output: "dba"

Example 2:

Input: [25,1,3,1,3,0,2]
Output: "adz"

Example 3:

Input: [2,2,1,null,1,0,null,0]
Output: "abc"

Note:

1. The number of nodes in the given tree will be between 1 and 1000.
2. Each node in the tree will have a value between 0 and 25.

We can use dfs to get all strings, sort them then get the smallest one. Even better, we can just keep a global variable of the current smallest string, each time we get a new string, compare it with the current smallest string and update it if necessary. This way it avoids keeping all the strings in a list and sorting them.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private String ans = null;
    
    public String smallestFromLeaf(TreeNode root) {
        dfs(root, new StringBuilder());
        return ans;
    }
    
    private void dfs(TreeNode node, StringBuilder sb) {
        if(node == null) {
            return;
        }
        sb.append((char)('a' + node.val));
        if(node.left == null && node.right == null) {
            sb.reverse();
            String s = sb.toString();
            sb.reverse();
            
            if(ans == null || s.compareTo(ans) < 0) {
                ans = s;
            }
        }
        dfs(node.left, sb);
        dfs(node.right, sb);
        sb.deleteCharAt(sb.length() - 1);
    }
}

StringBuilder vs StringBuffer

The StringBuilder class should generally be used in preference to the StringBuffer class, as it supports all of the same operations but it is faster, as it performs no synchronization. Instances of StringBuilder are not safe for use by multiple threads. If such synchronization is required then it is recommended that StringBuffer be used.