Python 递归 function 搜索二叉树

Question

Very new at Python and I'm trying to understand recursion over a binary tree. I've implemented a very simple tree, which funnily enough maps English characters to binary (1's and 0's). I've only used a very simple structure because I am struggling to get my head round a more complex question that I've been set. I figure if I can get my head round my example then I should be able to go away and look at the question I've been set myself.

The following creates the class BinaryTree and an instance of this

class BinaryTree:
    """A rooted binary tree"""
    def __init__(self):
        self.root = None
        self.left = None
        self.right = None

def is_empty(testtree: BinaryTree) -> bool:
        """Return True if tree is empty."""
        return testtree.root == testtree.left == testtree.right == None

def join(item: object, left: BinaryTree, right: BinaryTree) -> BinaryTree:
    """Return a tree with the given root and subtrees."""
    testtree = BinaryTree()
    testtree.root = item
    testtree.left = left
    testtree.right = right
    return testtree

EMPTY = BinaryTree()
C = join('C',EMPTY,EMPTY)
D = join('D',EMPTY,EMPTY)
E = join('E',EMPTY,EMPTY)
F = join('F',EMPTY,EMPTY)
A = join('A',C,D)
B = join('B',E,F)
BINARY = join('START',B,A)

I visualise it as follows

Visualisation of the Binary tree

Now I'm trying to create a function that will take two inputs, a BinaryTree and a single character and the output will be the binary code for the corresponding letter (as an example, D = " 10 "). I'm outputting as a string rather than an integer. My function and test case as follows

# global variable
result = ''

#Convert binary to letter
def convert_letter(testtree: BinaryTree, letter: str) -> str:
    global result
    if testtree == None:
        return False
    elif testtree.root == letter:
        return True        
    else:  
        if convert_letter(testtree.left, letter) == True:
            result += "1"
            return result
        elif convert_letter(testtree.right, letter) == True:
            result += "0"
            return result
     
#Test
test = 'D' #Return '10'
convert_letter(BINARY, test)

And unfortunately that's where I'm hitting a brick wall. I had tried initialising an empty string within the function, but everytime it iterates over the function it overwrites the string. Any help greatly appreciated.

Answer 1

I took the liberty of simplfying your code a bit let me know if you have any questions about how this works.

class node:
    """A rooted binary tree"""
    def __init__(self, value = None, left = None, right = None):
        self.value = value
        self.left = left
        self.right = right

C = node('C')
D = node('D')
E = node('E')
F = node('F')
A = node('A',C,D)
B = node('B',E,F)
BINARY = node('START',B,A)

def convert_letter(n,letter):
    if n.value == letter:
        return "1"+(convert_letter(n.left,letter) if not n.left is None else "")+(convert_letter(n.right,letter)if not n.right is None else "")
    else:
        return "0"+(convert_letter(n.left,letter) if not n.left is None else "")+(convert_letter(n.right,letter)if not n.right is None else "")

def walk(n):
    return n.value+(walk(n.left) if not n.left is None else "")+(walk(n.right) if not n.right is None else "")

test = 'D'
print(convert_letter(BINARY, test))
print(walk(BINARY))

Answer 2

This is not how I would personally structure an answer, but I think it most closely follows what you are attempting. The shortcoming of your answer only being that you are only returning one value, but kind of tracking two values. Note, I have taken the liberty of correcting:

BINARY = join('START',A,B)

Let's modify your method to return both a Boolean indicating if the letter was found as well as the indicator of the path.

def convert_letter2(testtree: BinaryTree, letter: str):
    if not testtree:
        return (False, "")

    if testtree.root == letter:
        return (True, "")

    test, val = convert_letter2(testtree.left, letter)
    if test:
        return (True, "1" + val)

    test, val = convert_letter2(testtree.right, letter)
    if test:
        return (True, "0" + val)

    return (False, "")

Then if we:

print(convert_letter2(BINARY, "D")[1])

We should get back "10"

Answer 3

The problem is that your function will sometimes return a boolean, sometimes a string, and sometimes None . So with this code:

    if convert_letter(testtree.left, letter) == True:
        result += "1"
        return result
    elif convert_letter(testtree.right, letter) == True:
        result += "0"
        return result

... you are not capturing all successful searches, as a successful search would return the actual string of "0" and "1" which obviously is not True . In that case the execution has no else to go to and returns None -- even when the letter was found in a deeper node.

Your function should not return a boolean -- that doesn't match the type hint either. It should be a string (the result). You could reserve None to indicate the letter was not found.

Some other problems:

• result += "0" will append the digit, but since you already made the recursive call, you need to prepend the digit -- as you are higher up in the tree now.

• The initialisation of your tree makes a different tree than you put in the image: A should be the left child, not the right child. So it should be join('START', A, B)

With those fixes, you'd have this code:

def convert_letter(testtree: BinaryTree, letter: str) -> str:
    global result
    if testtree is None:
        result = None  # Not found here 
    elif testtree.root == letter:
        result = ''  # Found! Start a path
    elif convert_letter(testtree.left, letter) is not None:
        result = "1" + result  # Prepend
    elif convert_letter(testtree.right, letter) is not None:
        result = "0" + result  # Prepend
    else:
        result = None  # Not found here
    return result

If you also correct to use join('START', A, B) , then the output will be 10 .

Better Practice

There are some things you can do better:

• Don't use a global variable for storing the function result. As you return it, you can capture the result you get from a recursive call as a local variable, prepend to it, and return it again.

• The definition of EMPTY makes your tree unnecessarily big. Just use None to denote an empty tree.

• Don't call a node's value root . A rooted tree has only one root, and it is a node, not a value of a node. So call that attribute value or data , but not root .

• The join function is nice, but why not use the constructor for that feature? The constructor can take those arguments as optional and immediately initialise the left and right attributes with those arguments.

• The code-comment above the convert_letter function describes the opposite from what the function does.

Taking all that into account, your code could look like this:

class BinaryTree:
    def __init__(self, value, left: 'BinaryTree'=None, right: 'BinaryTree'=None):
        self.value = value
        self.left = left
        self.right = right

def convert_letter(tree: BinaryTree, letter: str) -> str:
    if not tree:
        return # Not found here, return None
    if tree.value == letter:
        return ""  # Bingo: return an empty path
    # No more global. path is a local variable
    path = convert_letter(tree.left, letter)
    if path is not None:
        return "1" + path
    path = convert_letter(tree.right, letter)
    if path is not None:
        return "0" + path

# Look how nice it is to create a tree using the constructor arguments
binary = BinaryTree("Start",
    BinaryTree("A",
        BinaryTree("C"), BinaryTree("D")
    ),
    BinaryTree("B",
        BinaryTree("E"), BinaryTree("F")
    )
)

# Test
test = 'D'
print(convert_letter(binary, test))  # 10