从排序的数组中生成二叉搜索树

Question

Let's say I have a sorted array with [1,2,3,4,5], it should become a binary search tree with this array as its output: [4,2,5,1,3] (the brackets below represent the indices)

                               4 (0) 
                              /    \
                           2 (1)    5 (2)
                            /  \
                         1 (3)  3 (4)

While doing some research online, I found a link on this site that I could use to get this: Insert sorted array into binary search tree

I wanted to convert this to Python 3 without the use of any classes. This is what I have so far, but I'm stuck.

def bstlist(arr,start,end):
    newlst = []
    #start = arr[0]
    #end = arr[-1]
    if start > end:
        return [] #null

    mid = start + (end - start) / 2
    newlst = arr[mid]

I'm particularly confused about how to implement three lines of code in the Java implementation in Python:

TreeNode node = new TreeNode(arr[mid]);
node.left = sortedArrayToBST(arr, start, mid-1);
node.right = sortedArrayToBST(arr, mid+1, end);

How would I go about implementing them in Python ? And is there any other way to solve this in Python than the one listed in the link?

Answer 1

The traditional functional way to represent trees is to use lists or tuples for the nodes. Each node is just a value, a left tree, and a right tree (and a tree is just a node, the root of the tree, or None ).

Use lists if you want to mutate trees in-place; use tuples if you want to build a persistent tree where you generate new subnodes instead and the old ones are never mutated. Since the Java code you're looking at is mutating nodes, let's go with lists.

You can of course make this fancier by using a namedtuple in place of tuple or a dataclass (or use attrs off PyPI if you're not using Python 3.7+ and don't want to wait for a backport to your Python version) in place of list . (Or even just a dict .) This allows you to have nice names like .left (or ['left'] ) in place of sequence operations like [1] , but it doesn't actually change the functionality. Since we've decided to go with mutable, and we probably don't want to require Python 3.7 in early 2018—and besides, you said you don't want any classes—I'll stick with list .

# TreeNode node = new TreeNode(arr[mid]);
node = [arr[mid], None, None]

# node.left = sortedArrayToBST(arr, start, mid-1);
node[1] = sortedArrayToBST(arr, start, mid-1)

# node.right = sortedArrayToBST(arr, mid+1, end);
node[2] = sortedArrayToBST(arr, mid+1, end)

Answer 2

You really should use classes but if you don't want to you could use dictionaries instead.

def list_to_bst(l):
    if len(l) == 0:
        return None
    mid = len(l) // 2
    return {
        "value": l[mid],
        "left": list_to_bst(l[:mid]),
        "right": list_to_bst(l[mid+1:])
    }

you can then use it like so

list_to_bst([1, 2, 3, 4, 5])

Answer 3

You can complete your bstlist function using list:

def bstlist(arr, st, end):
    newlst = []
    if st > end:
        return []
    mid = st + (end-st)/2
    # adding the root list
    root = [arr[mid]]
    # getting the left list
    left = bstlist(arr, st, mid-1)
    # getting the right list
    right = bstlist(arr, mid+1, end)

    newlst = root + left+ right
    return newlst

calling the bstlist function will return you list, which is the order in which you should insert the number to get a balanced tree .

Example:

arr = [1,2,3,4,5]

bstarr = bstlist(arr, 0, len(arr)-1)

you will get bstarr as

[3, 1, 2, 4, 5]

it means you have to insert 3 first then 1 and so on.

The tree will look like this:

           3
         /   \
        1     4
         \     \
          2     5

To get the output as [3, 1, 4, 2, 5] you have to do level order traversal on the above formed binary search tree.