一般可以按下面步骤构建：
1，将所有左，右子树都为空的作为根节点。
2，在森林中选出两棵根节点的权值最小的树作为一棵新树的左，右子树，且置新树的附加根节点的权值为其左，右子树上根节点的权值之和。注意，左子树的权值应小于右子树的权值。
3，从森林中删除这两棵树，同时把新树加入到森林中。
4，重复2，3步骤，直到森林中只有一棵树为止，此树便是哈夫曼树。
下面是构建哈夫曼树的图解过程：
哈夫曼编码
利用哈夫曼树求得的用于通信的二进制编码称为哈夫曼编码。树中从根到每个叶子节点都有一条路径，对路径上的各分支约定指向左子树的分支表示”0”码，指向右子树的分支表示“1”码，取每条路径上的“0”或“1”的序列作为各个叶子节点对应的字符编码，即是哈夫曼编码。
就拿上图例子来说：
A，B，C，D对应的哈夫曼编码分别为：111，10，110，0
用图说明如下：
记住，设计电文总长最短的二进制前缀编码，就是以n个字符出现的频率作为权构造一棵哈夫曼树，由哈夫曼树求得的编码就是哈夫曼编码。
哈夫曼数的构造:
节点类
数据类型根据需要定义
Wight权重
Parent 父节点
Left child 左孩子
Right child右孩子
value实际值（比如是字符串，字符之类的等等...）
编码类
Bit[] 数组的每一个元素存放每一个叶子节点的哈夫曼编码的数组
Start 哈夫曼编码数组的下标
树类
构造树
求编码
解码
测试类
权值数组
实际值数组
树类： 首先要对有n个叶子节点的哈夫曼树来说，树共有2n-1个节点，有n-1个非叶子节点。
对所有节点初始化，节点的所有元素置-1，对n个叶子节点初始化的时候对权值和value进行赋值，
编码：只需要对n个叶子节点进行编码即可，对于有n个叶子节点哈夫曼编码，每个编码的最大长度为n-1位。
从每一个叶子节点开始，自底向上若左孩子的值为叶子节点则置当前bit的位为0，否则置1,注意对于置位是从第n-1位开始的。直到找到根节点，为止。
解码：bit数组的每一个元素都是一个叶子节点的二进制编码。从根节点（第n-1个节点为根节点）开始进行对比，从第一个元素开始，若其左孩子为0，则下次循环置其根节点为其左孩子，否则下次循环置其根节点为其右孩子，直到其左孩子和右孩子均为空的时候，输出当前节点的value即可。
节点类：
package 哈夫曼数和哈夫曼编码;
public class HNode {//节点类
int weight; //权值
int parent; //双亲节点
int leftChild; //左孩子
int rightChild; //右孩子
String value; //实际值
public HNode(){
}
}
编码类：
package 哈夫曼数和哈夫曼编码;
public class HCode {//编码类
public int bit[]; //求每一个叶子节点的哈夫曼编码数组
public int weight;
public int start; //编码数组开始的下标
public HCode(int n){
bit = new int[n];
// start = n-1;
}
}树类：
package 哈夫曼数和哈夫曼编码;
public class HTree { //树类
public int maxvalue=1000; //用于比较求最小值
public int nodenum;
public HTree(int n){
this.nodenum=n; //节点个数
}
public void haffman(int[] weight,String[] value, HNode[] node){
int n = this.nodenum;
int m1,m2,x1,x2; //m1,m2表示最小河次小的权值，x1,x2,表示两个最小权值对应的编号
//初始化所有节点，有n个叶子节点的哈夫曼树，有2n-1个节点
for(int i=0;i<2*n-1;i++){
HNode temp = new HNode();
if(i<n){
temp.weight=weight[i];
temp.value=value[i];
}else{
temp.weight=0;
temp.value="";
}
temp.parent=-1;
temp.leftChild=-1;
temp.rightChild=-1;
node[i]=temp;
}
//循环构造哈夫曼树,初始化n-1个非叶子节点，对于有n个叶子节点的哈夫曼树来说，有2n-1个节点，除了叶子节点还有n-1个节点
for(int i=0;i<n-1;i++){
m1=m2=maxvalue;
x1=x2=0;
for(int j=0;j<n+i;j++){
if(node[j].weight<m1&&node[j].parent==-1){
m1=m2;
x2=x1;
m1=node[j].weight;
x1=j;
}else if(node[j].weight<m2&&node[j].parent==-1){
m2=node[j].weight;
x2=j;
}
}
node[x1].parent=n+i;
node[x2].parent=n+i;
node[n+i].weight=node[x1].weight+node[x2].weight;
node[n+i].leftChild=x1;
node[n+i].rightChild=x2;
//node[n+i].leftChild=node[x1].weight;
//node[n+i].rightChild=node[x2].weight;
}
/*for(int i=0;i<2*n-1;i++){
System.out.println("parent:"+node[i].parent+"\tweight:"+node[i].weight+"\tleftChild:"+node[i].leftChild+"\trightChild:"
+ ""+node[i].rightChild+"\tvalue:"+node[i].value);
}*/ //用于测试
}
//哈夫曼编码算法
public void haffCode(HNode[] node, HCode[] hcode){
int n=this.nodenum;
int child,parent;
HCode code = new HCode(n);
for(int i=0;i<n;i++){ //对前面的n个叶子节点进行编码
code.start = n-1; //得到编码的最大长度为n-1
code.weight=node[i].weight;
child=i;
parent = node[child].parent;
while(parent!=-1){
if(node[parent].leftChild == child){
code.bit[code.start]=0;
}else{
code.bit[code.start]=1;
}
code.start--; //求编码的低一位
child = parent;
parent = node[child].parent;
}
//保存求出的叶子节点的哈夫曼编码和编码的起始位
HCode temp = new HCode(n);
for(int j=code.start+1;j<n;j++){
temp.bit[j]=code.bit[j];
}
temp.weight=code.weight;
temp.start=code.start;
hcode[i] = temp;
}
//输出以保存的哈夫曼编码
//printCode(node,hcode); //打印算法，用于测试
}
public void printCode(HNode[] node, HCode[] code){
for(int i=0;i<code.length;i++){
System.out.print("value"+node[i].value+"\tWeight="+code[i].weight+"\tCode=");
for(int j=code[i].start+1;j<code.length;j++){
System.out.print(code[i].bit[j]);
}
System.out.println();
}
}
//解码算法
public void yima(HCode[] code, HNode[] node){
for(int i=0;i<code.length;i++){
int temp=node.length-1; //根节点
//int j=0;
boolean asd = true;
int m=0;
while(node[temp].leftChild!=-1&&node[temp].rightChild!=-1){
if(asd==true){
/*
*
*/
m=code[i].start+1;
}
if(code[i].bit[m]==0){
temp = node[temp].leftChild;
}else{
temp = node[temp].rightChild;
}
m++;
asd=false;
}
//System.out.println(node[temp].value); //输出用于测试
}
}
}测试类：
package 哈夫曼数和哈夫曼编码;
public class Test {
public static void main(String[] args){
int[] arr = {2,5,8,3,9,6,12};
String[] str = {"Aasda","B","D","S","R","E","C"};
HNode[] node = new HNode[arr.length*2-1];
HCode[] hcode = new HCode[arr.length];
HTree tree= new HTree(arr.length);
System.out.println("---构造哈夫曼树---");
tree.haffman(arr, str, node);
System.out.println("---根据哈夫曼树编码---");
tree.haffCode(node, hcode);
System.out.println("---译码---");
tree.yima(hcode, node);
}
}测试结果：
经测试无误，若有错误请指出，谢谢！
