4.2 赫夫曼树数据结构

介绍

来自百度百科

1. 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树。
2. 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1。
3. 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积。
4. 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL。

代码

给一组数据作为节点权值，构造一棵赫夫曼树。

构造一棵赫夫曼树：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 依据给定数组数据 构造 huffman树
 * @author dxt
 *
 */
public class HuffmanTree {
	public static void main(String[] args) {
		int arr[] = {13, 3, 6, 9, 5, 20, 64};
		
		Node root = createHuffmanTree(arr);
		if(root != null) {
			root.preOrder();
		}
	}
	
	//创建huffman树
	public static Node createHuffmanTree(int[] arr) {
		//1. 依据数组arr构造节点，然后将节点保存到ArrayList中
		List<Node> nodes = new ArrayList<Node>();
		for(int temp : arr) {
			Node n = new Node(temp);
			nodes.add(n);
		}
		
		while(nodes.size() > 1) {
			//2. 将nodes中的节点进行排序，使用sort方法，sort方法会调用在Node类中重写的compareTo()方法
			Collections.sort(nodes);
		
			//3. 构造树
			//3.1 取出权值最小的两个节点
			Node leftNode = nodes.get(0);
			Node rightNode = nodes.get(1);
			//3.2 构建一个新的二叉树,其中parent.value = left.value + right.value
			Node parent = new Node(leftNode, rightNode);
			//3.3 nodes删除使用的两个节点，添加此新构建的节点
			nodes.remove(leftNode);
			nodes.remove(rightNode);
			nodes.add(parent);
		}
		
		//4. 返回nodes中剩余的节点，即是huffman树的根
		return nodes.get(0);
	}
}

构造过程中使用到的Node类

/**
 * 节点类
 * @author dxt
 *
 */
public class Node implements Comparable<Node>{
	int value;		//节点权值
	Node left;		//指向左子节点
	Node right;		//指向右子节点
	
	public Node(int value) {
		this.value = value;
	}
	public Node(Node left, Node right) {
		this.value = left.value + right.value;
		this.left = left;
		this.right = right;
	}
	
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
	
	//重写toString()方法
	public String toString() {
		return "Node: value = " + this.value;
	}

	@Override
	public int compareTo(Node o) {
		//从小到达进行排序
		return this.value - o.value;
	}
}