赫夫曼编码的Java实现
上次egg写了一个赫夫曼算法的java实现，我在此也把自己的劣作搬上来让高人指点，
其实这是我们老师布置的一个作业，后来发现本班大部分男生竟然抄袭女生的代码，并且
也交了差，实让我愤怒，为了给男同胞们争口气，我决定自己写一个，也算是对得住自己
了！
程序描述 ：赫夫曼算法一般用于数据压缩，应用于远程通信中可以减少数据流量，从而保持比较好的传输速度。下面的程序实现的功能是：从外部传进一个字符串对象，程序根据
该字符串构造赫夫曼编码。例如：字符串s="我我我 是 一 个贼贼aaaaa"，该字符串
有3个空格，其赫夫曼编码的一种如下：
个:01101
:00
我:10
a:11
是:0101
一:11101
贼:001
构造出来的赫夫曼树的结构如下：
第0个:【叶节点值：3；父节点值：6】
第1个:【叶节点值：3；父节点值：6】
第2个:【叶节点值：1；父节点值：3】
第3个:【叶节点值：1；父节点值：2】
第4个:【叶节点值：1；父节点值：2】
第5个:【叶节点值：2；父节点值：5】
第6个:【叶节点值：5；父节点值：10】
第7个:【节点值：2；父节点值：3；左孩子：1；右孩子：1】
第8个:【节点值：3；父节点值：5；左孩子：1；右孩子：2】
第9个:【节点值：5；父节点值：10；左孩子：2；右孩子：3】
第10个:【节点值：6；父节点值：16；左孩子：3；右孩子：3】
第11个:【节点值：10；父节点值：16；左孩子：5；右孩子：5】
第12个:【根节点值：16；左孩子：6；右孩子：10】
1，定义赫夫曼树节点class
package cn.hunnu.huffman;
/**
* 赫夫曼节点类
* @author: 肖波
*
*/
public class HuffmanNode {
private int weight=0;//结点权值
private HuffmanNode parent=null;//父节点
private HuffmanNode lchild=null;//左孩子
private HuffmanNode rchild=null;//右孩子
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public HuffmanNode getParent() {
return parent;
}
public void setParent(HuffmanNode parent) {
this.parent = parent;
}
public HuffmanNode getLchild() {
return lchild;
}
public void setLchild(HuffmanNode lchild) {
this.lchild = lchild;
}
public HuffmanNode getRchild() {
return rchild;
}
public void setRchild(HuffmanNode rchild) {
this.rchild = rchild;
}
public String toString(){
if(parent==null){
return "【根节点值："+weight+"；左孩子："+
lchild.getWeight()+"；右孩子："+rchild.getWeight()+"】";
}
else if(lchild==null&&rchild==null){
return "【叶节点值："+weight+"；父节点值："+parent.getWeight()+"】";
}else
return "【节点值："+weight+"；父节点值："+parent.getWeight()+"；左孩子："+
lchild.getWeight()+"；右孩子："+rchild.getWeight()+"】";
}
}
2，赫夫曼树
package cn.hunnu.huffman;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* 赫夫曼树定义
* @author: 肖波
*
*/
public class HuffmanTree {
private List<HuffmanNode> htree;//用于存放赫夫曼节点的列表
private Map<Character,HuffmanNode> charMap;//一个字符对应一个赫夫曼结点的映射对象。
/**
* 根据传入得字符串参数构造赫夫曼树
* @param str
*/
public HuffmanTree(String str){
htree = new ArrayList<HuffmanNode>();
//构造字符队列，用于存放所有的字符。
List<Character> charList = new ArrayList<Character>();
for(int i = 0;i<str.length();i++){
charList.add(str.charAt(i));
}
//构造一个映射，用于存放字符及其赫夫曼节点。
charMap = new HashMap<Character,HuffmanNode>();
while(charList.size()>0){//初始化charMap对象和htree叶节点
int count = 0;
for(int k = 0;k<charList.size();k++){
if(charList.get(0).equals(charList.get(k))){
count++;
if(k>0){
charList.remove(k);
k--;
}
}
}
HuffmanNode node = new HuffmanNode();//创建叶节点
node.setWeight(count);
charMap.put(charList.remove(0),node);
htree.add(node);
}
if(charMap.size()<2){//如果只传进一个字符，则不能构成赫夫曼树。
System.out.println("不构成赫夫曼树的条件！");
return ;
}
//非叶节点赋值
for(int i = 0;i<(charMap.size()-1);i++){
HuffmanNode parent = new HuffmanNode();
//选出权值最小的一个节点
HuffmanNode min1 = htree.get(htree.size()-1);
for(int j = 0;j<htree.size();j++){
if((null==htree.get(j).getParent())&&
htree.get(j).getWeight()<=min1.getWeight()){
min1 = htree.get(j);
}
}
min1.setParent(parent);
parent.setLchild(min1);
//选出权值次于最小权值的节点
HuffmanNode min2 = null;
for(int j = 0;;j++){
if(null==htree.get(j).getParent()){
min2 = htree.get(j);//用于比较大小的参照物
break;
}
}
for(int j = 0;j<htree.size();j++){
if(htree.get(j).getParent()==null&&
(htree.get(j).getWeight()<=min2.getWeight())){
min2 = htree.get(j);
}
}
min2.setParent(parent);
parent.setRchild(min2);
parent.setWeight(min1.getWeight()+min2.getWeight());
htree.add(parent);
}
}
/**
* 获取赫夫曼树
* @return
*/
public HuffmanTree getHuffmanTree(){
return this;
}
/**
* 获得赫夫曼编码，
* 例如： a:00
* b:10
* e:1
* @return 赫夫曼树的全部赫夫曼编码，以字符串的形式表示。
*/
public String getHuffmanCode(){
if(null==htree){//如果赫夫曼树为空，返回null。
return null;
}
StringBuffer stbu = new StringBuffer();
Iterator<Character> it = charMap.keySet().iterator();
while(it.hasNext()){
Character c = it.next().charValue();
HuffmanNode node = charMap.get(c);
stbu.append(c+":"+getHuffmanNodeCode(node)+"\r\n");
}
return stbu.toString();
}
/**
* 获得指定节点的赫夫曼编码
* @param node 赫夫曼节点
* @return 节点的赫夫曼编码
*/
public String getHuffmanNodeCode(HuffmanNode node){
String code = "";
if(null==node.getParent()){
return code;
}
if(node.equals(node.getParent().getLchild())){
//是父节点的左孩子
code = "0"+getHuffmanNodeCode(node.getParent());
}
else if(node.equals(node.getParent().getRchild())){
//是右孩子
code = "1"+getHuffmanNodeCode(node.getParent());
}
return code;
}
public List<HuffmanNode> getHtree() {
return htree;
}
public void setHtree(List<HuffmanNode> htree) {
this.htree = htree;
}
public Map<Character, HuffmanNode> getCharMap() {
return charMap;
}
/**
* 赫夫曼树结构图：字符串表示。
*/
public String toString(){
StringBuffer strb = new StringBuffer("");
for(int i = 0;i<htree.size();i++){
strb.append("第"+i+"个:"+htree.get(i)+"\n");
}
return strb.toString();
}
}
3，测试类
import cn.hunnu.huffman.HuffmanTree;
public class TestString {
public static void main(String args[]){
HuffmanTree ht = new HuffmanTree("aabbb cccc我我是 ");
System.out.println(ht);//输出赫夫曼树结构
System.out.println(ht.getHuffmanCode());//输出所有叶节点的赫夫曼编码
}
}
4，测试结果 ：
第0个:【叶节点值：2；父节点值：4】 第1个:【叶节点值：3；父节点值：6】 第2个:【叶节点值：2；父节点值：4】 第3个:【叶节点值：4；父节点值：8】 第4个:【叶节点值：2；父节点值：3】 第5个:【叶节点值：1；父节点值：3】 第6个:【节点值：3；父节点值：6；左孩子：1；右孩子：2】 第7个:【节点值：4；父节点值：8；左孩子：2；右孩子：2】 第8个:【节点值：6；父节点值：14；左孩子：3；右孩子：3】 第9个:【节点值：8；父节点值：14；左孩子：4；右孩子：4】 第10个:【根节点值：14；左孩子：6；右孩子：8】 我:100 :001 b:10 c:11 是:000 a:101
2009.06.01日我又写道： 上面的程序对输入有严格的要求，附件中是修改后的程序，可以接受输入浮点类型。