python写代码，包括主程序求：若一棵树采用长子兄弟链存储结构t存储，设计一个算法求其高度。

下面是采用递归的方式实现求树的高度的 Python 代码：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.child = None
        self.sibling = None

def tree_height(root):
    if root is None:
        return 0
    else:
        child_height = tree_height(root.child)
        sibling_height = tree_height(root.sibling)
        return max(child_height + 1, sibling_height)

其中，`TreeNode` 是一个树节点类，包含节点的值、长子节点和兄弟节点。`tree_height` 函数用于递归地计算树的高度，返回树的高度。首先判断根节点是否为空，如果是，则树的高度为 0；否则，递归地计算根节点的长子节点和兄弟节点的高度，并返回其中的最大值加 1，即为整棵树的高度。

相关问题

python若一棵树采用长子兄弟链存储结构t存储，设计一个算法求其高度并进行测试

以下是一种求解该问题的递归算法：

def tree_height(t):
    if not t:  # 如果t为空树，高度为0
        return 0
    else:
        # 递归求解每个子树的高度，并取最大值加上1作为当前树的高度
        return max(tree_height(t.child), tree_height(t.next)) + 1

其中，`t.child`表示t的第一个子节点，`t.next`表示t的下一个兄弟节点。如果t为空树，则递归终止，返回0。

下面是一个测试样例，假设我们有以下一棵树：

        A
      / | \
     B  C  D
    / \   / \
   E   F G   H

使用长子兄弟链存储结构t存储，可以定义如下节点类：

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.child = None
        self.next = None

则可以按如下方式构建树：

A = TreeNode('A')
B = TreeNode('B')
C = TreeNode('C')
D = TreeNode('D')
E = TreeNode('E')
F = TreeNode('F')
G = TreeNode('G')
H = TreeNode('H')

A.child = B
B.next = C
C.next = D
B.child = E
E.next = F
D.child = G
G.next = H

最后，调用`tree_height(A)`即可计算出该树的高度，结果为3。

一棵树采用孩子链存储结构/或长子兄弟链存储结构(任选一种)，尝试编程实现：创建一棵树设计一个算法求高度设计一个算法实现树的层次遍历设计两个算法实现先根遍历和后根遍历并测试，以上代码由python实现

好的，我明白了。关于你的问题，以下是 python 实现的代码：

采用孩子链存储结构的树结点定义：

class TreeNode:
    def __init__(self, data=None, children=None):
        self.data = data
        self.children = children if children else []

采用长子兄弟链存储结构的树结点定义：

class TreeNode:
    def __init__(self, data=None, first_child=None, next_sibling=None):
        self.data = data
        self.first_child = first_child
        self.next_sibling = next_sibling

创建一棵树：

def create_tree():
    # 构造一个示例树
    root = TreeNode("A")
    node_b = TreeNode("B")
    node_c = TreeNode("C")
    node_d = TreeNode("D")
    node_e = TreeNode("E")
    node_f = TreeNode("F")
    node_g = TreeNode("G")
    node_h = TreeNode("H")
    node_i = TreeNode("I")
    node_j = TreeNode("J")
    node_k = TreeNode("K")

    root.children = [node_b, node_c, node_d]
    node_b.children = [node_e, node_f]
    node_c.children = [node_g]
    node_d.children = [node_h, node_i, node_j]
    node_h.children = [node_k]

    return root

求树的高度：

def get_height(root):
    if not root:  # 空树高度为0
        return 0

    if not root.children:  # 叶节点高度为1
        return 1

    return 1 + max(get_height(child) for child in root.children)

树的层次遍历：

def level_order(root):
    if not root:
        return []

    queue = [root]
    levels = []
    while queue:
        level_size = len(queue)
        level = []
        for i in range(level_size):
            node = queue.pop(0)
            level.append(node.data)
            queue.extend(node.children)
        levels.append(level)

    return levels

先根遍历：

def pre_order(root):
    if root:
        print(root.data)
        for child in root.children:
            pre_order(child)

后根遍历：

def post_order(root):
    if root:
        for child in root.children:
            post_order(child)
        print(root.data)

测试：

def test():
    root = create_tree()

    # 测试求高度算法
    print("树的高度为：", get_height(root))

    # 测试树的层次遍历算法
    levels = level_order(root)
    print("树的层次遍历结果为：")
    for level in levels:
        print(level)

    # 测试先根遍历算法
    print("先根遍历结果为：")
    pre_order(root)

    # 测试后根遍历算法
    print("后根遍历结果为：")
    post_order(root)

if __name__ == "__main__":
    test()