哈夫曼树和哈夫曼编码（java）

哈夫曼树和哈夫曼编码（java）

哈夫曼树的概念，参考博客哈夫曼树

哈夫曼树，也就是带权路径长度最小的二叉树，最优二叉树。
构造一个最优二叉树，每次都取最小的两个元素构成树。

具体代码实现：
1、哈夫曼结点类

/**
 * 哈夫曼节点类
 * 
 * @author kiki
 *
 */
public class HaffNode {
	int weight; // 权值
	int flag; // 标志（是否叶子节点）
	int parent; // 双亲节点下标
	int leftChild; // 左孩子下标
	int rightChild; // 右孩子下标

	public HaffNode() {
	}

	@Override
	public String toString() {
		return "HaffNode [weight=" + weight + ", flag=" + flag + ", parent=" + parent + ", leftChild=" + leftChild
				+ ", rightChild=" + rightChild + "]";
	}
}

2、哈夫曼编码类
示例数组[1, 3, 5, 7]构成哈夫曼树
哈夫曼编码，从根节点到叶子结点，左结点为0，右结点为1；
数组哈夫曼编码分别为：0100， 0101， 0011， 0000

import java.util.Arrays;

/**
 * 哈夫曼编码
 * 
 * @author kiki 2018年11月26日
 */
public class HaffmanCode {

	int[] bit; // 编码数组
	int start; // 编码起始下标
	int weight; // 字符权值

	public HaffmanCode(int n) {
		bit = new int[n];
		start = n - 1;
	}

	@Override
	public String toString() {
		return "HaffmanCode [bit=" + Arrays.toString(bit) + ", start=" + start + ", weight=" + weight + "]";
	}
}

3、哈夫曼树构建类

/**
 * 哈夫曼树和哈夫曼编码
 * @author kiki 2018年11月27日
 */
public class HaffmanTree {
	static final int MAX_VALUE = 1000; // 最大权值
	static int nodeNum; // 叶子结点数量
	static int totalNum; // 结点总数

	public HaffmanTree(int n) {
		nodeNum = n;
		totalNum = 2 * n - 1;
	}

	public static void main(String[] args) {
		int[] values = { 1, 3, 5, 7 }; // 叶子节点
		int n = values.length;
		HaffmanTree haffmanTree = new HaffmanTree(n);
		// 初始化哈夫曼树结点
		HaffNode[] nodes = new HaffNode[totalNum];
		haffmanTree.buildHaffmanTree(values, nodes);
		// 初始化哈夫曼编码
		HaffmanCode[] codes = new HaffmanCode[nodeNum];
		haffmanTree.buildHaffmanCode(nodes, codes);
		for (int i = 0; i < totalNum; i++) {
			System.out.println("weight: " + nodes[i]);
			if (i < nodeNum) {
				System.out.print(" | code: " + codes[i]);
			}
			System.out.println();
		}
	}

	/**
	 * 构建哈夫曼树
	 * 
	 * @param values
	 * @param nodes
	 */
	private void buildHaffmanTree(int[] values, HaffNode[] nodes) {
		// 初始化结点数组
		for (int i = 0; i < totalNum; i++) {
			HaffNode node = new HaffNode();
			if (i < nodeNum) { // 叶子节点
				node.weight = values[i];
			} else {
				node.weight = 0;
			}
			node.flag = 0;
			node.parent = -1;
			node.leftChild = -1;
			node.rightChild = -1;
			nodes[i] = node;
		}
		// 遍历数组，比较出最小的两个结点，构成树
		/*
		 * i=0;j<4 i=1;j<5 i=2;j<6 i=3;j<7
		 */
		// 非叶子结点数量nodeNum-1
		// 构造非叶子结点过程
		for (int i = 0; i < nodeNum - 1; i++) {
			int value1 = MAX_VALUE;// 最小树权值
			int value2 = MAX_VALUE;// 次小树权值
			int index1 = 0; // 最小树索引
			int index2 = 0; // 次小树索引
			int tempTotalNum = nodeNum + i;
			for (int j = 0; j < tempTotalNum; j++) {
				if (nodes[j].weight < value1 && nodes[j].flag == 0) {
					// 如果匹配值比最小结点小，将当前最小树变为次小树
					value2 = value1;
					index2 = index1;
					// 将匹配值变为最小树
					value1 = nodes[j].weight;
					index1 = j;
				} else if (nodes[j].weight < value2 && nodes[j].flag == 0) {
					value2 = nodes[j].weight;
					index2 = j;
				}
			}
			// 父结点权值为子结点权值加和
			nodes[tempTotalNum].weight = nodes[index1].weight + nodes[index2].weight;
			nodes[tempTotalNum].leftChild = index1;
			nodes[tempTotalNum].rightChild = index2;
			// 最小树结点
			nodes[index1].flag = 1; // 已标记
			nodes[index1].parent = tempTotalNum;
			// 次小树结点
			nodes[index2].flag = 1; // 已标记
			nodes[index2].parent = tempTotalNum;
		}
	}

	/**
	 * 构建哈夫曼编码
	 * 
	 * @param nodes
	 * @param codes
	 */
	private void buildHaffmanCode(HaffNode[] nodes, HaffmanCode[] codes) {

		// 由哈夫曼树构造哈夫曼编码
		int n = nodeNum;
		HaffmanCode code = new HaffmanCode(n);
		int child, parent;
		// 求n个叶结点的哈夫曼编码
		for (int i = 0; i < n - 1; i++) {
			code.start = n - 1;		// 不等长编码的最后一位为n-1
			code.weight = nodes[i].weight;// 取得编码对应的权值
			child = i;
			parent = nodes[child].parent;

			while (parent != -1) {
				// 由叶结点向上直到根结点循环
				if (nodes[parent].leftChild == child) {
					code.bit[code.start] = 0;// 左孩子结点编码为0
				} else {
					code.bit[code.start] = 1;// 右孩子结点编码1
				}
				code.start--;
				child = parent;
				parent = nodes[child].parent;
			}
			HaffmanCode temp = new HaffmanCode(n);
			// 保存叶结点的编码和不等长编码的起始位
			for (int j = code.start + 1; j < n; j++) {
				temp.bit[j] = code.bit[j];
			}
			temp.start = code.start;
			temp.weight = code.weight;
			codes[i] = temp;
		}
	}

}

运行结果：

HaffNode [weight=1, flag=1, parent=4, leftChild=-1, rightChild=-1]
HaffmanCode [bit=[0, 1, 0, 0], start=0, weight=1]
HaffNode [weight=3, flag=1, parent=4, leftChild=-1, rightChild=-1]
HaffmanCode [bit=[0, 1, 0, 1], start=0, weight=3]
HaffNode [weight=5, flag=1, parent=5, leftChild=-1, rightChild=-1]
HaffmanCode [bit=[0, 0, 1, 1], start=1, weight=5]
HaffNode [weight=7, flag=1, parent=6, leftChild=-1, rightChild=-1]
null
HaffNode [weight=4, flag=1, parent=5, leftChild=0, rightChild=1]

HaffNode [weight=9, flag=1, parent=6, leftChild=4, rightChild=2]

HaffNode [weight=16, flag=0, parent=-1, leftChild=3, rightChild=5]