华为od算法_生成哈夫曼树_Java

华为od算法_生成哈夫曼树_Java

题目

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

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

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

在树节点中，左节点权值小于等于右节点权值，根节点权值为左右节点权值之和。 当左右节点权值相同时，左子树高度高度小于等于右子树。 注意: 所有用例保证有效，并能生成哈夫曼树提醒:哈夫曼树又称最优二叉树，是一种带权路径长度最短的一叉树。

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

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

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

示例1 输入： 5 5 15 40 30 10

输出： 40 100 30 60 15 30 5 15 10

说明： 根据输入，生成哈夫曼树，按照中序遍历返回。所有节点中，左节点权值小于等于右节点权值之和。当左右节点权值相同时左子树高度小于右子树。

代码

//哈夫曼结点类
class HuffmanNode implements Comparable<HuffmanNode> {
    // 权重、左子树、右子树
    int weight;
    HuffmanNode left;
    HuffmanNode right;
 
    //构造函数
    // 叶子结点
    public HuffmanNode(int weight) {
        this.weight = weight;
    }
 
    // 有子树的结点
    public HuffmanNode(int weight, HuffmanNode left, HuffmanNode right) {
        this.weight = weight;
        this.left = left;
        this.right = right;
    }
 
    // 重写compare方法，1、根据权重大小（小左大右）2、根据结点高度（小左大右）
    @Override
    public int compareTo(HuffmanNode o) {
        if(this.weight != o.weight){
            return this.weight - o.weight;
        } else {
            return getHeight(this) - getHeight(o);
        }
    }
 
    //求树的高度
    public int getHeight(HuffmanNode node){
        if(node == null){
            return 0;
        }
        return 1 + Math.max(getHeight(node.left), getHeight(node.right));
    }
}
public class Test3 {
    // 哈夫曼树构建
    public static HuffmanNode buildHuffman(int[] weights){
        // 定义优先级队列，用来存放权重
        PriorityQueue<HuffmanNode> pq = new PriorityQueue<HuffmanNode>();
        //将权重值依次加入优先级队列中
        for(int i = 0; i<weights.length; i++){
            pq.add(new HuffmanNode(weights[i]));
        }
        // 依次取最小的两个结点出来，相加之后再放入队列，直到队列只有一个根结点
        while(pq.size() > 1){
            HuffmanNode node1 = pq.poll();
            HuffmanNode node2 = pq.poll();
            HuffmanNode node3 = new HuffmanNode(node1.weight + node2.weight, node1,node2);
            pq.add(node3);
        }
        return pq.poll();
    }
 
    //中序遍历哈夫曼树
    public static void inOrderTravel(HuffmanNode node, StringBuilder result){
        if(node != null){
            inOrderTravel(node.left, result);
            result.append(node.weight + " ");
            inOrderTravel(node.right, result);
        }
    }
 
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        if(n <= 0){
            return;
        }
        int[] weights = new int[n];
        for(int i = 0; i < n; i++){
            weights[i] = scan.nextInt();
        }
        scan.close();
        HuffmanNode data = buildHuffman(weights);
        StringBuilder result = new StringBuilder();
        inOrderTravel(data, result);
        System.out.println(result);
    }
}