哈夫曼编码(java版)

发布于:2021-10-14 09:04:24

哈夫曼树又叫最优二叉树,是一类带权路径最短的二叉树。哈夫曼树是二叉树的一种应用,在信息检索中很常用。


哈夫曼树可以用来解决报文编码问题,在通信领域有着非常广泛的运用。具体什么是带权路径二叉树,什么是哈夫曼编码这里不做介绍,这里只介绍代码,必须先知道这些概念才能阅读代码!


以下为全部代码,做了比较详细的注释,所以不做另外解释


节点类:



package huffman_binary_tree;

//树结点
public class Node {
private String data;
private Node leftNode;
private Node rightNode;
//结点的权值
private double weight;
public Node(String data,double weight){
this.data=data;
this.weight=weight;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}
public Node getRightNode() {
return rightNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "Node[data="+data+",weight="+weight+"]";
}

}


哈夫曼树具体实现类:



package huffman_binary_tree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

//哈夫曼树
public class HuffmanTree {
/**
* 节点集合
*/
private List nodes=new ArrayList();
/**
* 添加结点
* @param node
* @return
*/
public HuffmanTree addNode(Node node){
nodes.add(node);
return this;
}
/**
* 快速排序
*/
private void quickSort(){
sort(0,nodes.size()-1);
}
/**
* 快速排序的具体实现过程
* @param start
* @param end
*/
private void sort(int start,int end){
if(start double temp=nodes.get(start).getWeight();
int i=start;
int j=end+1;
while(true){
while(i while(j>start&&nodes.get(--j).getWeight()>=temp);
if(i swap(i,j);
}else{
break;
}
}
swap(start,j);
sort(start,j-1);
sort(j+1,end);
}
}
/**
* 结点交换
* @param i
* @param j
*/
private void swap(int i,int j){
Node temp;
temp=nodes.get(i);
nodes.set(i, nodes.get(j));
nodes.set(j, temp);
}
/**
* 生成哈夫曼树,返回根结点
* @return
*/
public Node crreateHuffmanTree(){
//当结点集合中只有一个结点(即根结点)时结束
while(nodes.size()>1){
//对当前结合中的结点进行排序(结点集合中的结点个数每次都会改变)
quickSort();
//取到两个权值最小的结点
Node left=nodes.get(0);
Node right=nodes.get(1);
//新结点
Node newNode=new Node(null,left.getWeight()+right.getWeight());
newNode.setLeftNode(left);
newNode.setRightNode(right);

//移除两个最小的结点
nodes.remove(0);
nodes.remove(0);

//添加新结点
nodes.add(newNode);
}
//返回根结点
return nodes.get(0);
}
//广度优先遍历(需要借助队列)
public List breadthFirst(Node root){
//保存结果集
List lists=new ArrayList();
//队列
Queue queue=new ArrayDeque();
if(root!=null){
//加入结点到队列中
queue.offer(root);
}
//如果队列为空,则结束
while(!queue.isEmpty()){
//peek方法不移除结点
lists.add(queue.peek());
//弹出且移除
Node p=queue.poll();
//如果左结点不为空,则加入队列
if(p.getLeftNode()!=null){
queue.offer(p.getLeftNode());
}
//如果右结点不为空,则加入队列
if(p.getRightNode()!=null){
queue.offer(p.getRightNode());
}
}
return lists;
}

}


哈夫曼编码实现类:



package huffman_binary_tree;

import java.util.HashMap;
import java.util.Map;

public class HuffmanCoding {
Map map=new HashMap();
public Map coding(Node root){
process(root,"");
return map;
}
private void process(Node node,String content){
//叶子结点
if(node.getLeftNode()==null){
map.put(node.getData(), content);
return;
}
//对左子树分配代码"0"
process(node.getLeftNode(),content+"0");
//对右子树分配代码"1"
process(node.getRightNode(),content+"1");
}
}


测试类:



package huffman_binary_tree;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

//最优二叉树,哈夫曼树
public class Main {
public static void main(String[] args) {
HuffmanTree tree=new HuffmanTree();
tree.addNode(new Node("A",40.0))
.addNode(new Node("B",8.0))
.addNode(new Node("C",10.0))
.addNode(new Node("D",30.0))
.addNode(new Node("E",10.0))
.addNode(new Node("F",2.0));
Node root=tree.crreateHuffmanTree();

//广度遍历
// List lists=tree.breadthFirst(root);
// for(Node node:lists){
// System.out.println(node);
// }

HuffmanCoding coding=new HuffmanCoding();
Map map=coding.coding(root);
Set mapSet=map.keySet();
//TreeSet实现排序
TreeSet set=new TreeSet(mapSet);
Iterator iterator=set.iterator();
while(iterator.hasNext()){
String str=iterator.next();
System.out.println(str+":"+map.get(str));
}
}

}


输出结果:



A:0
B:1101
C:1110
D:10
E:1111
F:1100





相关推荐

最新更新

猜你喜欢