完全二叉树的建立python

可以使用列表来存储完全二叉树，通过计算节点的下标来进行访问和操作。具体实现可以参考以下代码：

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

def build_complete_binary_tree(nums):
    n = len(nums)
    if n == 0:
        return None
    root = TreeNode(nums[0])
    queue = [root]
    i = 1
    while i < n:
        node = queue.pop(0)
        if i < n:
            node.left = TreeNode(nums[i])
            queue.append(node.left)
            i += 1
        if i < n:
            node.right = TreeNode(nums[i])
            queue.append(node.right)
            i += 1
    return root

这个函数接收一个列表作为输入，返回一个完全二叉树的根节点。我们可以通过遍历这个树来访问每一个节点，进行各种操作。

相关问题

建立函数创建该完全二叉树。

这里给出一个基于列表的方式创建完全二叉树的函数示例：

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

def create_complete_binary_tree(lst):
    """
    基于列表创建完全二叉树
    :param lst: 列表
    :return: 完全二叉树的根节点
    """
    if not lst:
        return None
    root = Node(lst[0])
    queue = [root]
    i = 1
    while i < len(lst):
        node = queue.pop(0)
        left_val = lst[i] if i < len(lst) else None
        right_val = lst[i+1] if i+1 < len(lst) else None
        if left_val:
            node.left = Node(left_val)
            queue.append(node.left)
        if right_val:
            node.right = Node(right_val)
            queue.append(node.right)
        i += 2
    return root

这个函数的基本思路是，从列表中取出第一个元素作为二叉树的根节点，然后按照完全二叉树的特点，依次将列表中的元素添加到二叉树的左右子树中。这里使用了一个队列来存储待添加子节点的父节点，这个队列的初始化元素就是根节点。在添加子节点的时候，我们需要先从队列中取出一个父节点，然后再添加其左右子节点，并将这些子节点加入到队列中以便后续处理。最后返回根节点即可。

建立一个完全二叉树，能够统计二叉树的叶子结点的个数，求二叉树的深度的python代码

以下是Python代码实现：

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

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        left_depth = self.get_depth(root.left)
        right_depth = self.get_depth(root.right)
        if left_depth == right_depth:
            return 2 ** left_depth + self.countNodes(root.right)
        else:
            return 2 ** right_depth + self.countNodes(root.left)

    def get_depth(self, root: TreeNode) -> int:
        if not root:
            return 0
        depth = 0
        while root:
            depth += 1
            root = root.left
        return depth

对于一个完全二叉树，可以利用完全二叉树的性质来统计叶子节点的个数和深度。可以通过递归的方式来实现，如果左子树和右子树的深度相同，那么左子树一定是满二叉树，可以通过公式 $2^h-1$ 来计算左子树的节点数，同时递归计算右子树的节点数；如果左子树的深度比右子树深度大一，那么右子树一定是满二叉树，同样可以通过公式 $2^h-1$ 来计算右子树的节点数，同时递归计算左子树的节点数。对于深度的计算，可以从根节点一直往左子树遍历，得到深度。