非递归直接求解满秩二叉树中序遍历【原创】【原作者】

# 作者：陈墨仙
# 定义二叉树节点类

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

# 构建满秩四层二叉树
def build_full_binary_tree():
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(7)
    root.left.left.left = TreeNode(8)
    root.left.left.right = TreeNode(9)
    root.left.right.left = TreeNode(10)
    root.left.right.right = TreeNode(11)
    root.right.left.left = TreeNode(12)
    root.right.left.right = TreeNode(13)
    root.right.right.left = TreeNode(14)
    root.right.right.right = TreeNode(15)
    return root

# 中序遍历二叉树[递归解]
def inorder_traversal(root):
    if root is None:
        return []
    return inorder_traversal(root.left) + [root.val] + inorder_traversal(root.right)

# 测试
tree_root = build_full_binary_tree()
result = inorder_traversal(tree_root)
print(result)


# 满秩二叉树中序遍历非递归解
# 假设总结点为n,以下所有除法为向下取整
# 第一个结点【1】的位置在 它的位置在 (n/2) + 1   这里开始是树的第1层
# 第二个结点【2】的位置在 它的位置在 (n/2/2)+1   这里开始是树的第2层
# 第三个结点【3】的位置在 它的位置在 n - 2个节点位置 + 1
# 第四个结点【4】的位置在 (n/2/2/2)+1           这里开始是树的第3层
# 第五个结点【5】的位置在 (n/2/2) + (n/2/2)
# 第六个结点【6】的位置在 n - 5的位置 + 1
# 第七个结点【7】的位置在 n - 4的位置 + 1
# 第8个结点            (n/2/2/2/2) + 1      这里开始是树的第4层
#   9                 (n/2/2/2) + (n/2/2/2) + (n/2/2/2)
#   10               (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2)
#  11                (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2) + (n/2/2/2)
# 12                 n - 11的位置 + 1
# 13                 n - 10的位置 + 1
# 14                  n - 9的位置 + 1
#15                   n-8的位置 + 1

# 第k个结点，k<2的j次方且k>2的j-1次方时，为第j层。 k-2的j次方的差，为k在该层的偏移。第j层的第一个结点，位置是 (n/2/...)+1其中/2的次数为j次，
# 第j层的结点分布的位置是对称的
# 已知第j层第一个结点的位置，则第j层最后一个结点的位置是总结点数n-第一个结点的位置+1
# 那么第j层前半部分结点，从第二个开始遵循 (n/2...)*(j+2*偏移量)其中/2的次数为j次，后半部分结点位置与前半部分对称

def divide_2_n(n,  times):
    for i in range(times):
        n = int(n / 2)
    return n
def find_position(k, n):
    layer = 1
    while k > 2**(layer)-1:
        layer += 1
    power = 2**(layer-1)
    current_layer_nods = 2**(layer) - 2**(layer-1)
    if k == 1:
        return (divide_2_n(n, 1)) + 1
    else:
        offset = k - power
        if offset == 0:
            return divide_2_n(n, layer) + 1
        elif offset == current_layer_nods-1:
            return n - divide_2_n(n, layer)
        elif offset < current_layer_nods / 2:
            return (divide_2_n(n, layer-1))*(layer-1+2*(offset-1))
        else:
            return n - (divide_2_n(n, layer-1)) * (layer-1 + 2 * (current_layer_nods-offset-2)) + 1


a = {}
for dd in range(1, 16):
    a[find_position(dd, 15)] = dd
print(a)