python构造哈夫曼树，并初步利用graphviz实现哈夫曼树的可视化

不说废话
graphviz安装地址
https://graphviz.gitlab.io/_pages/Download/windows/graphviz-2.38.msi
https://www2.graphviz.org/Packages/stable/windows/10/msbuild/Release/Win32/graphviz-2.38-win32.msi
然后命令行输入
pip install graphviz
最后上代码

import graphviz
import sys
class TreeNode(object):
    def __init__(self, data):
        self.data =data
        self.code = ""
        self.weight = ""
        self.lchild = None
        self.rchild = None
class creatTree():
    def __init__(self):
        pass
    def creatnodeQ(self, codes):  # 主要是被下一个函数Tree（）调用
        self.q = []
        for code in codes:
            self.q.append(TreeNode(code)) #构建出内容全是节点对象的列表，利用权值构建该列表
        return  self.q
    def Tree(self, codes):                  #输入权值序列，升序排序输入一个列表，如：k=[1,2,3,4,5,6,7,8,9]
        self.k = self.creatnodeQ(codes)
        m=0
        i = 0
        j = len(self.k)
        #构建哈夫曼树的主要算法如下：
        #因为已经排好序，所以k[i].data ，k[i + 1].data是列表k中最小的值
        #s=self.k[i].data + self.k[i + 1].data
        #所以s就是最小的两个权值之和
        #算法主要是构建一个self.k.insert(q,TreeNode(s))
        #找到合适的地方插入列表k
        #然后再出栈，剔除列表中k[x].data两个最小的值
        #重复这些过程，知道len(k)=1后跳出循环
        while (j != 1):
            q=0
            for q in range(0, len(self.k)):
                s=self.k[i].data + self.k[i + 1].data
                if (s <= self.k[q].data):
                    q=q
                    self.k.insert(q,TreeNode(s))
                    self.tree = []
                    self.tree.append(self.k[i])
                    self.k[q].lchild=self.tree
                    self.tree = []
                    self.tree.append(self.k[i+1])
                    self.k[q].rchild = self.tree

                    # p = tree[0].data
                    #print(q,self.k[q].data,self.k[i].data,self.k[i+1].data)
                    break

                if (s > self.k[j-1].data):
                    s = self.k[i].data + self.k[i + 1].data
                    q=j
                    self.k.append(TreeNode(s))

                    self.tree = []
                    self.tree.append(self.k[i])
                    self.k[q].lchild = self.tree
                    self.tree = []
                    self.tree.append(self.k[i + 1])
                    self.k[q].rchild = self.tree
                    # print(q, self.k[q].data, self.k[i].data, self.k[i + 1].data,"q")
                    # print(self.k[q].data,self.k[q].lchild[0].data,self.k[q].rchild[0].data)
                    break
            self.k.pop(0)
            self.k.pop(0)
            j = len(self.k)
            if(j==1):
                return self.k
#haffuman_tree(k)：将哈夫曼树可视化
# 利用先序遍历算法，和栈的知识，把根结点发放在栈中，根结点
#的级别越高，越接近栈底，如父结点就放在栈底node[0].每遍历一个节点后，将其放入栈中，
# 并创造相应的节点如：node.append(str(k[0].data))
#         g.node(name=node[len(node)-1], color='red')
# 当每遍历到叶节点时
#就将其放到栈中，此时利用函数连接栈的，后两位数据（也就是加在函数最后的代码的字符，
# if (len(node) >= 2):
#       g.edge(node[len(node) - 2], node[len(node) - 1], color='green')
#        print(node[len(node) - 2], node[len(node) - 1])
#  node.pop()
#然后出栈
#循环这个过程就可以实现哈夫曼树可视化了

def hafuman_tree(k):
    if (k != []):
        print(k[0].data)
        node.append(str(k[0].data))
        g.node(name=node[len(node)-1], color='red')
    try:
        hafuman_tree(k[0].lchild)
    except:
        pass
    try:
        hafuman_tree(k[0].rchild)
    except:
        pass
    if (len(node) >= 2):
        g.edge(node[len(node) - 2], node[len(node) - 1], color='green')
        print(node[len(node) - 2], node[len(node) - 1])
    node.pop()
    #g.view() #去掉注释有惊喜
    if (len(node) == 0):
        g.view()

if __name__ == '__main__':
    k=[1,2,3,4,5,6,7,8,9]
    cs = creatTree()                #创建一个实例
    s=cs.Tree(k)                    #调用该实例，构建一个树

    g = graphviz.Digraph(filename="cs", format='png')  #这三行代码必须合在一起
    node=[]                                             #才可画出哈夫曼树
    hafuman_tree(s)                                      #传入一个树，然后画图

输入结点
k=[1,2,3,4,5,6,7,8,9]

运行结果
哈弗曼树图