Python完全二叉树

创建树节点【TN】
创建树【FBT】
打印树【FBT.tree】

import math
# Tree Node
class TN:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right
    def __str__(self):
        return str(self.data)


# Full Binary Tree
class FBT:
    def __init__(self, ls):
        self.nodes = [TN(i) for i in ls]
        for i in range(len(self.nodes)-1, 0, -1):
            if i % 2 == 0:
                self.nodes[int(i/2-1)].right = self.nodes[i]
            else:
                self.nodes[int(i/2)].left = self.nodes[i]
        self.tree()
    # 树结构
    def tree(self):
        # 节点数
        length = len(self.nodes)
        # 总层数
        layers = math.ceil(math.log2(length))
        # 总宽度
        width = 2 ** layers - 1
        # 分隔符
        branch = ' '
        # 初始化顶层,并打印
        layer = [self.nodes[0].data]
        interval = 2 ** layers - 1
        for i in range(2, length + 1):
            if math.log2(i) % 1 == 0:
                # 打印当前层
                print((branch * interval).join(layer).center(width))
                layer = []
            # 元素进入当前层
            layer.append(self.nodes[i - 1].data)
            # 节点间空隙
            interval = 2 ** (layers - int(math.log2(i))) - 1
        # 打印底层
        print(branch.join(layer))

递归法遍历

# 先序遍历
def preorder_traversal(node):
    print('%3s' % node, end='')
    if node.left:
        preorder_traversal(node.left)
    if node.right:
        preorder_traversal(node.right)
# 中序遍历
def inorder_traversal(node):
    if node.left:
        inorder_traversal(node.left)
    print('%3s' % node, end='')
    if node.right:
        inorder_traversal(node.right)
# 后序遍历
def postorder_traversal(node):
    if node.left:
        postorder_traversal(node.left)
    if node.right:
        postorder_traversal(node.right)
    print('%3s' % node, end='')


# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)
print('\npreorder')
preorder_traversal(fbt.nodes[0])
print('\ninorder')
inorder_traversal(fbt.nodes[0])
print('\npostorder')
postorder_traversal(fbt.nodes[0])

递归的运行效率较低，可使用【列表】的方法进行遍历

# 先序遍历
def preorder_traversal(node):
    ls = []
    while True:
        # 节点不为空时
        while node:
            print('%3s' % node, end='')
            # 入栈
            ls.append(node)
            # 进入左节点
            node = node.left
        # 栈为空时退出
        if ls == []:
            break
        # 出栈
        node = ls.pop()
        # 进入右节点
        node = node.right
# 中序遍历
def inorder_traversal(node):
    ls = []
    while True:
        # 节点不为空时
        while node:
            # 入栈
            ls.append(node)
            # 进入左节点
            node = node.left
        # 栈为空时退出
        if ls == []:
            break
        # 出栈
        node = ls.pop()
        print('%3s' % node, end='')
        # 进入右节点
        node = node.right
# 后序遍历，难度较大，以后再补充
def postorder_traversal(node):
    pass


# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)
print('\npreorder')
preorder_traversal(fbt.nodes[0])
print('\ninorder')
inorder_traversal(fbt.nodes[0])

层序遍历

from collections import deque
# 层序遍历
def level_order(node):
    print('\nlevel order')
    # 根节点入队
    q = deque([node])
    # 先进先出
    while q:
        node = q.popleft()
        print('%3s' % node, end='')
        if node.left:
            q.append(node.left)
        if node.right:
            q.append(node.right)


# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)
level_order(fbt.nodes[0])

探索树的深度

# 树深度,递归法
def depth(node):
    if node is None:
        return 0
    dl = depth(node.left)
    dr = depth(node.right)
    return max(dl, dr) + 1


# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)

# the depth of tree
print('the depth of tree:', depth(fbt.nodes[0]))

遍历指定层

from collections import deque
# 层序遍历
def level_order(node, layer=2):
    print('\nlevel order')
    # 根节点入队
    q = deque([(node, 1)])
    # 先进先出
    while q:
        node, depth = q.popleft()
        if depth == layer:
            print('%3s' % node, end='')
        if node.left:
            q.append((node.left, depth + 1))
        if node.right:
            q.append((node.right, depth + 1))


# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)
level_order(fbt.nodes[0], layer=5)