python 数组转完全二叉树

在刷Leetcode时候，经常遇到给定数据数组，然后blabla。。。。

在调试阶段，需要先把数组转为二叉树，这里面有多种需求：

1. 一个数组直接转为从上到下、从左到右的二叉树

2. 一个有序数组，转为搜索二叉树

数组转完全二叉树实现（python）

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# None 值不占用内存
def array_to_bitree(array):
    if len(array) == 0:
        return TreeNode(None)
    root = TreeNode(array[0])
    node_list = [root]
    for i in range(1, len(array)):
        val = array[i]
        if val != None:
            node = TreeNode(val)
            node_list.append(node)
            if i % 2 == 1:
                node_list[int((i-1)/2)].left = node
            if i % 2 == 0:
                node_list[int((i - 2) / 2)].right = node
        else:
            node_list.append(None)
    return root

# None值占用内存
def array_to_bitree_2(array):
    if len(array) == 0:
        return TreeNode(None)
    root = TreeNode(array[0])
    node_list = [root]
    for i in range(1, len(array)):
        val = array[i]
        node = TreeNode(val)
        node_list.append(node)
        if i % 2 == 1:
            node_list[int((i-1)/2)].left = node
        if i % 2 == 0:
            node_list[int((i - 2) / 2)].right = node

    return root

def print_bitree(root):
    stack = [root]
    while len(stack) > 0:
        node = stack.pop(0)
        print(node.val, end=', ')
        if node.left != None:
            stack.append(node.left)
        if node.right != None:
            stack.append(node.right)



if __name__ == '__main__':
    # arr = [1, 2, 3, 4, 5, 6, None, 7, None, 8]
    # arr = [1, 2, 2, None, 3, None, 3]
    arr = [1, 2, 2, 3, 4, 4, 3]
    print(arr)

    root = array_to_bitree_2(arr)
    print_bitree(root)

运行结果，可以直接复现原有的数组

有序数组转搜索二叉树：

def array_to_search_tree(array):
    if len(array) == 0:
        return TreeNode(array[0])
    mid = len(array) // 2  # ????????????
    if len(array) > 0:
        root = TreeNode(array[mid])
        if len(array[:mid]) > 0:
            root.left = array_to_search_tree(array[:mid])
        if len(array[mid + 1:]) > 0:
            root.right = array_to_search_tree(array[mid + 1:])
    return root

 

附录：二叉树遍历方法

def inorder(root):
    res = []
    if not root:
        return res
    stack = []
    while root or stack:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        res.append(root.val)
        root = root.right
    return res
def preorder(root):
    res = []
    if not root:
        return res
    stack = []
    stack.append(root)
    while stack:
        root = stack.pop()
        res.append(root.val)
        if root.right:
            stack.append(root.right)
        if root.left:
            stack.append(root.left)
    return res
def postorder(root):
    res_temp = []
    res = []
    if not root:
        return res
    stack = []
    stack.append(root)
    while stack:
        root = stack.pop()
        res_temp.append(root.val)
        if root.left:
            stack.append(root.left)
        if root.right:
            stack.append(root.right)
    while res_temp:
        res.append(res_temp.pop())
    return res

# Recursive Implementation
def inorder_rec(root, res=None):
    if root is None:
        return []
    if res is None:
        res = []
    inorder_rec(root.left, res)
    res.append(root.val)
    inorder_rec(root.right, res)
    return res
# Recursive Implementation
def preorder_rec(root, res=None):
    if root is None:
        return []
    if res is None:
        res = []
    res.append(root.val)
    preorder_rec(root.left, res)
    preorder_rec(root.right, res)
    return res
def postorder_rec(root, res=None):
    if root is None:
        return []
    if res is None:
        res = []
    postorder_rec(root.left, res)
    postorder_rec(root.right, res)
    res.append(root.val)
    return res

def level_order(root):
    ans = []
    if not root:
        return ans
    level = [root]
    while level:
        current = []
        new_level = []
        for node in level:
            current.append(node.val)
            if node.left:
                new_level.append(node.left)
            if node.right:
                new_level.append(node.right)
        level = new_level
        ans.append(current)
    return ans

def level_order2(root):
    if not root:
        return []
    ans = []
    stack = [root]
    while len(stack) > 0:
        node = stack.pop(0)
        ans.append(node.val)
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)
    return ans

def zigzag_level(root):
    res = []
    if not root:
        return res
    level = [root]
    flag = 1
    while level:
        current = []
        new_level = []
        for node in level:
            current.append(node.val)
            if node.left:
                new_level.append(node.left)
            if node.right:
                new_level.append(node.right)
        level = new_level
        res.append(current[::flag])
        flag *= -1
    return res