编写一个程序显示递归树

以下是一个 Python3 实现的递归树程序：

import turtle

def tree(branch_len, t):
    if branch_len > 5:
        t.forward(branch_len)
        t.right(20)
        tree(branch_len-15, t)
        t.left(40)
        tree(branch_len-15, t)
        t.right(20)
        t.backward(branch_len)

def main():
    t = turtle.Turtle()
    my_win = turtle.Screen()
    t.left(90)
    t.up()
    t.backward(100)
    t.down()
    t.color("green")
    tree(75, t)
    my_win.exitonclick()

main()

该程序使用 Python 的 turtle 模块绘制递归树。当 branch_len 大于 5 时，程序会向前画一条线段，然后先向右转 20 度，再递归地调用 tree 函数，画出右子树；接着向左转 40 度，再递归地调用 tree 函数，画出左子树；最后向右转 20 度，回到原来的位置。当 branch_len 小于等于 5 时，不再画线段，直接返回。

相关问题

Tkinter编写一个程序显示递归树

好的，以下是一个简单的Tkinter程序，用于显示递归树。

import tkinter as tk

# 递归函数，用于绘制树
def draw_tree(canvas, x, y, length, angle, depth):
    if depth == 0:
        return
    # 计算下一个节点的坐标
    x1 = x + int(length * tk.cos(tk.radians(angle)))
    y1 = y - int(length * tk.sin(tk.radians(angle)))
    # 绘制当前节点和下一个节点之间的线段
    canvas.create_line(x, y, x1, y1)
    # 递归绘制下一个节点的子节点
    draw_tree(canvas, x1, y1, length // 2, angle - 30, depth - 1)
    draw_tree(canvas, x1, y1, length // 2, angle + 30, depth - 1)

# 创建一个窗口
window = tk.Tk()
window.title("递归树")

# 创建一个画布
canvas_width = 500
canvas_height = 500
canvas = tk.Canvas(window, width=canvas_width, height=canvas_height)
canvas.pack()

# 绘制树
start_x = canvas_width // 2
start_y = canvas_height - 50
draw_tree(canvas, start_x, start_y, 150, -90, 7)

# 进入消息循环
window.mainloop()

程序的主要部分是递归函数`draw_tree`，用于绘制树。它接收`canvas`、当前节点的坐标`(x, y)`、当前节点的长度`length`、当前节点的角度`angle`、当前节点的深度`depth`作为参数。如果深度为0，则直接返回。否则，计算下一个节点的坐标`(x1, y1)`，绘制当前节点和下一个节点之间的线段，然后递归绘制下一个节点的子节点。

在主程序中，创建一个窗口和一个画布，然后调用`draw_tree`函数绘制树。在本例中，树的起点位于画布的中心底部，长度为150，角度为-90，深度为7。您可以根据需要更改这些参数。

最后，进入消息循环以显示窗口和画布。运行程序后，您将看到一个递归树的图像。

编写一个程序显示递归树Python，运用tkinter

以下是一个简单的示例程序，可以用递归方式显示二叉树：

import tkinter as tk

class BinaryTree:
    def __init__(self, value):
        self.value = value
        self.left_child = None
        self.right_child = None

    def insert_left(self, value):
        if self.left_child is None:
            self.left_child = BinaryTree(value)
        else:
            new_node = BinaryTree(value)
            new_node.left_child = self.left_child
            self.left_child = new_node

    def insert_right(self, value):
        if self.right_child is None:
            self.right_child = BinaryTree(value)
        else:
            new_node = BinaryTree(value)
            new_node.right_child = self.right_child
            self.right_child = new_node

def draw_tree(canvas, node, x, y, x_offset, y_offset):
    if node is None:
        return

    # Draw node
    canvas.create_oval(x-10, y-10, x+10, y+10, fill='blue')
    canvas.create_text(x, y, text=node.value)

    # Draw left child
    draw_tree(canvas, node.left_child, x-x_offset, y+y_offset, x_offset/2, y_offset)

    # Draw right child
    draw_tree(canvas, node.right_child, x+x_offset, y+y_offset, x_offset/2, y_offset)

if __name__ == '__main__':
    # Create binary tree
    tree = BinaryTree('A')
    tree.insert_left('B')
    tree.insert_right('C')
    tree.left_child.insert_left('D')
    tree.left_child.insert_right('E')
    tree.right_child.insert_left('F')
    tree.right_child.insert_right('G')

    # Create canvas
    root = tk.Tk()
    canvas = tk.Canvas(root, width=600, height=400)
    canvas.pack()

    # Draw tree
    draw_tree(canvas, tree, 300, 50, 200, 50)

    tk.mainloop()

运行程序后，将会显示一个递归树：