哈夫曼树---贪婪法
2016-01-12 21:30
344 查看
哈夫曼算法
第一步:初始化n个单节点的树,并为它们标上字母表中的字符。把每个字符的概率记在树的根中,用来指出树的权重(更一般地来说,树的权重等于树中所有叶子节点的概率之和)
第二步:重复下面的步骤,直到只剩一棵单独的树。找到两棵权重最小的树,把它们作为新树中的左右子树,并把其权重之和作为新的权重记录在新树的根中。
上面的算法所构造的树称之为哈夫曼树。
哈夫曼节点代码:
public class Node<T> implements Comparable<Node<T>> {
private T data;
private double weight;
private Node<T> left;
private Node<T> right;
public Node(T data, double weight){
this.data = data;
this.weight = weight;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public Node<T> getLeft() {
return left;
}
public void setLeft(Node<T> left) {
this.left = left;
}
public Node<T> getRight() {
return right;
}
public void setRight(Node<T> right) {
this.right = right;
}
@Override
public String toString(){
return "data:"+this.data+";weight:"+this.weight;
}
@Override
public int compareTo(Node<T> other) {
if(other.getWeight() > this.getWeight()){
return 1;
}
if(other.getWeight() < this.getWeight()){
return -1;
}
return 0;
}
}
构造哈夫曼树和遍历哈夫曼树代码:
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
public class HuffmanTree<T> {
public static <T> Node<T> createTree(List<Node<T>> nodes){
while(nodes.size() > 1){
//假如用优先队列的话,排序算法的复杂度就可以变成插入优先队列的时间复杂度logn
Collections.sort(nodes);
Node<T> left = nodes.get(nodes.size()-1);
Node<T> right = nodes.get(nodes.size()-2);
Node<T> parent = new Node<T>(null, left.getWeight()+right.getWeight());
parent.setLeft(left);
parent.setRight(right);
nodes.remove(left);
nodes.remove(right);
nodes.add(parent);
}
return nodes.get(0);
}
public static <T> List<Node<T>> breadth(Node<T> root){
List<Node<T>> list = new ArrayList<Node<T>>();
Queue<Node<T>> queue = new ArrayDeque<Node<T>>();
if(root != null){
queue.offer(root);
}
while(!queue.isEmpty()){
list.add(queue.peek());
Node<T> node = queue.poll();
if(node.getLeft() != null){
queue.offer(node.getLeft());
}
if(node.getRight() != null){
queue.offer(node.getRight());
}
}
return list;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Node<String>> list = new ArrayList<Node<String>>();
list.add(new Node<String>("a",7));
list.add(new Node<String>("b",5));
list.add(new Node<String>("c",4));
list.add(new Node<String>("d",2));
Node<String> root = HuffmanTree.createTree(list);
System.out.println(HuffmanTree.breadth(root));
// System.out.println(list);
}
}
第一步:初始化n个单节点的树,并为它们标上字母表中的字符。把每个字符的概率记在树的根中,用来指出树的权重(更一般地来说,树的权重等于树中所有叶子节点的概率之和)
第二步:重复下面的步骤,直到只剩一棵单独的树。找到两棵权重最小的树,把它们作为新树中的左右子树,并把其权重之和作为新的权重记录在新树的根中。
上面的算法所构造的树称之为哈夫曼树。
哈夫曼节点代码:
public class Node<T> implements Comparable<Node<T>> {
private T data;
private double weight;
private Node<T> left;
private Node<T> right;
public Node(T data, double weight){
this.data = data;
this.weight = weight;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public Node<T> getLeft() {
return left;
}
public void setLeft(Node<T> left) {
this.left = left;
}
public Node<T> getRight() {
return right;
}
public void setRight(Node<T> right) {
this.right = right;
}
@Override
public String toString(){
return "data:"+this.data+";weight:"+this.weight;
}
@Override
public int compareTo(Node<T> other) {
if(other.getWeight() > this.getWeight()){
return 1;
}
if(other.getWeight() < this.getWeight()){
return -1;
}
return 0;
}
}
构造哈夫曼树和遍历哈夫曼树代码:
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
public class HuffmanTree<T> {
public static <T> Node<T> createTree(List<Node<T>> nodes){
while(nodes.size() > 1){
//假如用优先队列的话,排序算法的复杂度就可以变成插入优先队列的时间复杂度logn
Collections.sort(nodes);
Node<T> left = nodes.get(nodes.size()-1);
Node<T> right = nodes.get(nodes.size()-2);
Node<T> parent = new Node<T>(null, left.getWeight()+right.getWeight());
parent.setLeft(left);
parent.setRight(right);
nodes.remove(left);
nodes.remove(right);
nodes.add(parent);
}
return nodes.get(0);
}
public static <T> List<Node<T>> breadth(Node<T> root){
List<Node<T>> list = new ArrayList<Node<T>>();
Queue<Node<T>> queue = new ArrayDeque<Node<T>>();
if(root != null){
queue.offer(root);
}
while(!queue.isEmpty()){
list.add(queue.peek());
Node<T> node = queue.poll();
if(node.getLeft() != null){
queue.offer(node.getLeft());
}
if(node.getRight() != null){
queue.offer(node.getRight());
}
}
return list;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Node<String>> list = new ArrayList<Node<String>>();
list.add(new Node<String>("a",7));
list.add(new Node<String>("b",5));
list.add(new Node<String>("c",4));
list.add(new Node<String>("d",2));
Node<String> root = HuffmanTree.createTree(list);
System.out.println(HuffmanTree.breadth(root));
// System.out.println(list);
}
}
相关文章推荐
- C++实现哈夫曼树简单创建与遍历的方法
- 第六周作业——编码实现哈夫曼树
- 哈夫曼编码(HDU 1053)
- 最优编码问题(哈夫曼编码)(贪心)
- 数据结构之哈夫曼树
- 一颗名叫哈夫曼的树
- 哈夫曼树与哈夫曼编码
- 哈夫曼树,哈夫曼编码
- poj-3253哈夫曼树
- 二叉树总结
- 树之哈夫曼树(最优二叉树)
- 哈夫曼树及哈夫曼树编码
- 数据结构 JAVA描述(五)哈夫曼树,树与森林
- 2015-8-19数据结构学习-哈夫曼树
- 哈夫曼树实现
- Huffman编码的实现
- 数据结构例程——哈夫曼树
- poj 3253 Fence Repair(优先队列+哈夫曼树)
- 第六周作业1 -- 利用哈夫曼编码英文字母表
- poj 1521 Entropy