递归树插入只创建根节点

Question

My function is given a vector. It gets the maximum value from it and creates a root node for it. It then divides the vector in two at the index of this highest value (excluding that value itself). The left side of the vector should then be used recursively to set the root's left child. The same should happen at the right.

But my code is only filling in the root node. Why?

import numpy as np

class Node:
    def __init__(self, information):
        self.information = information
        self.left = None
        self.right = None

class Max_Tree:
    def __init__(self):
        self.root = None

    def insert(self, array):
        if len(array) == 0:
            return 0
        max_value_index = np.argmax(array)
        self.root = Node(array[max_value_index])
        array_left = array[0: max_value_index]
        array_right = array[max_value_index + 1:]
        self._insert(array_left, self.root.left)
        self._insert(array_right, self.root.right)

    def _insert(self, array, node):
        if len(array) == 0:
            return 0
        max_value_index = np.argmax(array)
        node = Node(array[max_value_index])
        array_left = array[0: max_value_index]
        array_right = array[max_value_index + 1:]
        self._insert(array_left, node.left)
        self._insert(array_right, node.right)

Example run:

array = np.array([2, 42, 17, 13, 21, 50, 32, 9, 14])
max_tree = Max_Tree()
max_tree.insert(array)
print(max_tree.root.information)  # OK
print(max_tree.root.left)  # None ???? Why ???

Answer 1

The problem is that when you call self._insert , the second argument is always None . In Python arguments are passed by value, so in this case there is just the value None ... there is no way the function is going to update the variable of the caller: it has its own parameter variable, and only that variable will get the reference to the new Node that it creates. But that reference is lost when the function returns. So all that work is done for nothing.

Instead, design your self._insert function so that it will not take that second argument, but will return the Node it creates for the given array. Then it is the caller's responsibility to assign that returned Node instance to whatever property ( left , right , root , ...).

Here is how self._insert should be adapted:

def _insert(self, array):
    if len(array) == 0:
        return  # Return None!

    max_value_index = np.argmax(array)
    node = Node(array[max_value_index])
    array_left = array[0: max_value_index]
    array_right = array[max_value_index + 1:]

    node.left = self._insert(array_left)  # Assign the returned Node instance (or None)
    node.right = self._insert(array_right)  # Same priniciple

    return node  # Return the new Node with all its descendants

Once you have this, the main self.insert function does not have to repeat any of this code. It can just delegate the call to self._insert and assign the result to the root:

def insert(self, array):
    self.root = self._insert(array)