This explanation clearly walks through how frequency-driven structure makes Huffman coding efficient, especially with the step-by-step tree construction example. The idea of prioritizing high-frequency elements is similar to how systems like pay per call life insurance leads focus on value concentration rather than uniform distribution.

Python Recursive approach

def get_value(node: Node, code: str, s: str, i: int) -> tuple[str, int]:
    
    if node is None:
        return code, i
        
    # leaf node
    if node.data != '\x00':
        code += str(node.data)
        return code, i
        
    if i >= len(s):
        return code, i
        
    # not leaf node
    match s[i]:
        case '0':
            return get_value(node.left, code, s, i+1)
            
        case '1':
            return get_value(node.right, code, s, i+1)
            
        case _:
            raise ValueError('Invalid Input')

def decodeHuff(root, s):

    i: int = 0
    out_str: str = ''
    while i < len(s):
        out_str, i = get_value(root, out_str, s, i)

    print(out_str)
		
		

void decode(String s, Node root) {        
    Node node = root;

    for (int i = 0; i < s.length(); i++) {
        node = s.charAt(i) == '0' ? node.left : node.right;

        if (node.left == null && node.right == null) {
            System.out.print(node.data);
            node = root;
        }
    }
}

There is an error in the python's test script. The input should be encoded values, however it inputs the string.

This test code is broken for Javascript, The code was expecting that i should do encode and decode both. However question was for decoding the string and it should provide root node and encoded string. Just printing the input string passed it.