1. PingCode智库首页
  2. 百科

python中如何画出二叉树

Edit1 • • 百科

python中如何画出二叉树

在Python中画出二叉树的几种方法包括：使用文本表示、利用图形库如matplotlib或graphviz、使用专门的数据结构和算法库如BinaryTree、利用网络框架如D3.js。以下详细描述了使用matplotlib的方法。

一、文本表示二叉树

文本表示是一种简单且直观的方法，适用于小型二叉树。通常，我们使用递归函数来生成树的结构，并将其打印到控制台。

1.1、实现代码

class Node:


    def __init__(self, key):


        self.left = None


        self.right = None


        self.val = key


def print_tree(root, level=0, prefix="Root: "):


    if root is not None:


        print(" " * (level * 4) + prefix + str(root.val))


        if root.left is not None or root.right is not None:


            if root.left is not None:


                print_tree(root.left, level + 1, "L--- ")


            else:


                print(" " * ((level + 1) * 4) + "L--- None")


            if root.right is not None:


                print_tree(root.right, level + 1, "R--- ")


            else:


                print(" " * ((level + 1) * 4) + "R--- None")


示例用法


root = Node(1)


root.left = Node(2)


root.right = Node(3)


root.left.left = Node(4)


root.left.right = Node(5)


print_tree(root)

二、使用matplotlib绘制二叉树

matplotlib是一个强大的图形绘制库，使用它可以绘制更复杂和美观的二叉树。

2.1、实现代码

import matplotlib.pyplot as plt


import networkx as nx


class Node:


    def __init__(self, key):


        self.left = None


        self.right = None


        self.val = key


def add_edges(graph, root, pos, x=0, y=0, layer=1):


    if root is not None:


        graph.add_node(root.val, pos=(x, y))


        if root.left is not None:


            graph.add_edge(root.val, root.left.val)


            l = x - 1 / layer


            add_edges(graph, root.left, pos, x=l, y=y-1, layer=layer+1)


        if root.right is not None:


            graph.add_edge(root.val, root.right.val)


            r = x + 1 / layer


            add_edges(graph, root.right, pos, x=r, y=y-1, layer=layer+1)


def draw_tree(root):


    graph = nx.DiGraph()


    pos = {}


    add_edges(graph, root, pos)


    pos = nx.get_node_attributes(graph, 'pos')


    nx.draw(graph, pos, with_labels=True, arrows=False)


    plt.show()


示例用法


root = Node(1)


root.left = Node(2)


root.right = Node(3)


root.left.left = Node(4)


root.left.right = Node(5)


draw_tree(root)

三、使用graphviz绘制二叉树

graphviz是一个开源的图形可视化软件，特别适用于绘制树和有向图。

3.1、安装graphviz

pip install graphviz

3.2、实现代码

from graphviz import Digraph


class Node:


    def __init__(self, key):


        self.left = None


        self.right = None


        self.val = key


def add_edges(dot, root):


    if root is not None:


        if root.left is not None:


            dot.edge(str(root.val), str(root.left.val))


            add_edges(dot, root.left)


        if root.right is not None:


            dot.edge(str(root.val), str(root.right.val))


            add_edges(dot, root.right)


def draw_tree(root):


    dot = Digraph()


    add_edges(dot, root)


    dot.render('binary_tree', format='png', view=True)


示例用法


root = Node(1)


root.left = Node(2)


root.right = Node(3)


root.left.left = Node(4)


root.left.right = Node(5)


draw_tree(root)

四、使用BinaryTree库

BinaryTree库是一个专门用于处理和可视化二叉树的Python库。

4.1、安装BinaryTree库

pip install binarytree

4.2、实现代码

from binarytree import Node, build, pprint


创建二叉树


root = Node(1)


root.left = Node(2)


root.right = Node(3)


root.left.left = Node(4)


root.left.right = Node(5)


打印二叉树


print(root)


生成并打印完全二叉树


nodes = [1, 2, 3, 4, 5, 6, 7]


complete_tree = build(nodes)


print(complete_tree)

五、使用D3.js绘制二叉树

D3.js是一个用于可视化数据的JavaScript库，可以生成交互式和动态的树形结构。

5.1、实现步骤

  1. 将二叉树数据保存为JSON格式。
  2. 使用HTML和JavaScript在网页中加载D3.js库。
  3. 使用D3.js的树形布局函数生成二叉树。

5.2、示例代码

<!DOCTYPE html>


<html>


<head>


    <script src="https://d3js.org/d3.v5.min.js"></script>


</head>


<body>


    <script>


        var treeData = {


            "name": "1",


            "children": [


                {


                    "name": "2",


                    "children": [


                        { "name": "4" },


                        { "name": "5" }


                    ]


                },


                { "name": "3" }


            ]


        };


        var margin = { top: 20, right: 90, bottom: 30, left: 90 },


            width = 960 - margin.left - margin.right,


            height = 500 - margin.top - margin.bottom;


        var svg = d3.select("body").append("svg")


            .attr("width", width + margin.right + margin.left)


            .attr("height", height + margin.top + margin.bottom)


            .append("g")


            .attr("transform", "translate(" + margin.left + "," + margin.top + ")");


        var i = 0,


            duration = 750,


            root;


        var treemap = d3.tree().size([height, width]);


        root = d3.hierarchy(treeData, function(d) { return d.children; });


        root.x0 = height / 2;


        root.y0 = 0;


        update(root);


        function update(source) {


            var treeData = treemap(root);


            var nodes = treeData.descendants(),


                links = treeData.descendants().slice(1);


            nodes.forEach(function(d){ d.y = d.depth * 180});


            var node = svg.selectAll('g.node')


                .data(nodes, function(d) { return d.id || (d.id = ++i); });


            var nodeEnter = node.enter().append('g')


                .attr('class', 'node')


                .attr("transform", function(d) {


                    return "translate(" + source.y0 + "," + source.x0 + ")";


                })


                .on('click', click);


            nodeEnter.append('circle')


                .attr('class', 'node')


                .attr('r', 1e-6)


                .style("fill", function(d) {


                    return d._children ? "lightsteelblue" : "#fff";


                });


            nodeEnter.append('text')


                .attr("dy", ".35em")


                .attr("x", function(d) {


                    return d.children || d._children ? -13 : 13;


                })


                .attr("text-anchor", function(d) {


                    return d.children || d._children ? "end" : "start";


                })


                .text(function(d) { return d.data.name; });


            var nodeUpdate = nodeEnter.merge(node);


            nodeUpdate.transition()


                .duration(duration)


                .attr("transform", function(d) {


                    return "translate(" + d.y + "," + d.x + ")";


                });


            nodeUpdate.select('circle.node')


                .attr('r', 10)


                .style("fill", function(d) {


                    return d._children ? "lightsteelblue" : "#fff";


                })


                .attr('cursor', 'pointer');


            var nodeExit = node.exit().transition()


                .duration(duration)


                .attr("transform", function(d) {


                    return "translate(" + source.y + "," + source.x + ")";


                })


                .remove();


            nodeExit.select('circle')


                .attr('r', 1e-6);


            nodeExit.select('text')


                .style('fill-opacity', 1e-6);


            var link = svg.selectAll('path.link')


                .data(links, function(d) { return d.id; });


            var linkEnter = link.enter().insert('path', "g")


                .attr("class", "link")


                .attr('d', function(d){


                    var o = {x: source.x0, y: source.y0}


                    return diagonal(o, o)


                });


            var linkUpdate = linkEnter.merge(link);


            linkUpdate.transition()


                .duration(duration)


                .attr('d', function(d){ return diagonal(d, d.parent) });


            var linkExit = link.exit().transition()


                .duration(duration)


                .attr('d', function(d) {


                    var o = {x: source.x, y: source.y}


                    return diagonal(o, o)


                })


                .remove();


            nodes.forEach(function(d){


                d.x0 = d.x;


                d.y0 = d.y;


            });


            function diagonal(s, d) {


                path = `M ${s.y} ${s.x}


                        C ${(s.y + d.y) / 2} ${s.x},


                          ${(s.y + d.y) / 2} ${d.x},


                          ${d.y} ${d.x}`


                return path


            }


            function click(d) {


                if (d.children) {


                    d._children = d.children;


                    d.children = null;


                } else {


                    d.children = d._children;


                    d._children = null;


                }


                update(d);


            }


        }


    </script>


</body>


</html>

六、总结

在Python中绘制二叉树有多种方法，可以根据需要选择合适的方法。文本表示简单直观，matplotlib和graphviz适合生成静态图，BinaryTree库提供了简单易用的接口，而D3.js则适合生成交互式和动态的图形。在具体项目中，可以根据需求选择最合适的方法来绘制二叉树。

相关问答FAQs：

1. 如何在Python中画出二叉树？

在Python中，您可以使用第三方库如matplotlib或graphviz来画出二叉树。这些库提供了丰富的绘图功能，可以帮助您以图形化的方式呈现二叉树的结构。

2. 有没有简单的方法可以在Python中画出二叉树？

是的，如果您只是想简单地可视化一个二叉树，您可以使用Python自带的turtle库。通过使用turtle库的绘图功能，您可以轻松地绘制出二叉树的形状，使其更加可视化和易于理解。

3. 如何在Python中绘制带有节点值的二叉树？

要在Python中绘制带有节点值的二叉树，您可以使用matplotlib库的绘图功能。首先，您需要将二叉树的节点和边转换为适合绘图的数据结构，例如使用字典或列表表示。然后，您可以使用matplotlib的绘图函数来创建一个图形对象，并根据节点和边的位置绘制出二叉树的形状，再将节点的值添加到对应的位置上。这样，您就可以在图形中看到每个节点的值了。

文章包含AI辅助创作，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/926765

赞 (0)
Edit1Edit1
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部