题目描述
给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。

请完成一个函数，根据输入的数字数组，生成哈夫曼树，并将哈夫曼树按照中序遍历输出。

为了保证输出的二叉树中序遍历结果统一，增加以下限制：

二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。当左右节点权值相同时，左子树高度小于等于右子树高度。

注意：

所有用例保证有效，并能生成哈夫曼树。

提醒：

哈夫曼树又称为最优二叉树，是一种带权路径长度最短的二叉树。

所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）

输入描述
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。

输出描述
输出一个哈夫曼树的中序遍历数组，数值间以空格分隔

用例1
输入
5
5 15 40 30 10
输出
40 100 30 60 15 30 5 15 10
说明
根据输入，生成哈夫曼树，按照中序遍历返回。所有节点中，左节点权值小于等于右节点权值之和。当左右节点权值相同时，左子树高度小于右子树。

#需要注意的是，只有当左右权值相同时才需要保证左子树高度小于等于右子树高度
import heapq
class Node:
    def __init__(self,lc,rc,height,weight):
        self.lc = lc #左孩子
        self.rc = rc #右孩子
        self.height = height #子树高度
        self.weight = weight  #权重

    def __gt__(self, other):
        #权重不同时，权重小的优先级高；相同时，高度小的优先级高
        if self.weight!=other.weight:
            return self.weight>other.weight
        else:
            return self.height>other.height
def midorder(root,seq):
    if root.lc is not None:
        midorder(root.lc,seq)
    seq.append(root.weight)
    if root.rc is not None:
        midorder(root.rc,seq)

n=int(input())
weights = list(map(int,input().split()))
#创建哈夫曼节点并加入到优先队列中
pq=[]
for weight in weights:
    heapq.heappush(pq,Node(None,None,0,weight))
while len(pq)>1:
    #取出两个最小的节点
    lc = heapq.heappop(pq)
    rc = heapq.heappop(pq)
    #合并节点
    fa_weight = lc.weight+rc.weight
    fa_height = max(lc.height,rc.height)+1
    heapq.heappush(pq,Node(lc,rc,fa_height,fa_weight))

root = heapq.heappop(pq)
seq=[]
midorder(root,seq)
print(' '.join(map(str,seq)))