哈夫曼树java代码 哈夫曼树csdn

哈夫曼树编码的应用（Java语言）

1）编写函数实现选择parent为0且权值最小的两个根结点的算法

创新互联建站坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站建设、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的勉县网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

2）编写函数实现统计字符串中字符的种类以及各类字符的个数。

3）编写函数构造赫夫曼树。

4）编写函数实现由赫夫曼树求赫夫曼编码表。

5）编写函数实现将正文转换为相应的编码文件。

6）编写函数实现将编码文件进行译码。

7）编写主控函数，完成本实验的功能。

哈夫曼编码与译码 java

class HaffmanNode //哈夫曼树的结点类

{

int weight; //权值

int parent,left,right; //父母结点和左右孩子下标

public HaffmanNode(int weight)

{

this.weight = weight;

this.parent=-1;

this.left=-1;

this.right=-1;

}

public HaffmanNode()

{

this(0);

}

public String toString()

{

return this.weight+", "+this.parent+", "+this.left+", "+this.right;

}

return code;

}

public static void main(String[] args)

{

int[] weight={5,29,7,8,14,23,3,11}; //指定权值集合

HaffmanTree htree = new HaffmanTree(weight);

System.out.println("哈夫曼树的结点数组:\n"+htree.toString());

String[] code = htree.haffmanCode();

System.out.println("哈夫曼编码:");

for (int i=0; icode.length; i++)

System.out.println(code[i]);

}

}

哈夫曼树

转自：

哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL=(W1 L1+W2 L2+W3 L3+...+ Wn Ln)，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,...n)。可以证明哈夫曼树的WPL是最小的。【例】给定4个叶子结点a，b，c和d，分别带权7，5，2和4。构造如下图所示的三棵二叉树(还有许多棵)，它们的带权路径长度分别为: (a)WPL=7 2+5 2+2 2+4 2=36 (b)WPL=7 3+5 3+2 1+4 2=46 (c)WPL=7 1+5 2+2 3+4 3=35其中(c)树的WPL最小，可以验证，它就是哈夫曼树。

构造哈夫曼树的算法如下： 1）对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F={T1,T2,T3,...,Ti,..., Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。 2）在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。 3）从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。 4）重复2）和3），直到集合F中只有一棵二叉树为止。 例如，对于4个权值为1、3、5、7的节点构造一棵哈夫曼树，其构造过程如下图所示：

可以计算得到该哈夫曼树的路径长度WPL＝(1+3) 3+2 5+1*7=26。

哈夫曼编码应用 大数据 量的图像信息会给存储器的存储容量，通信干线信道的带宽，以及计算机的处理速度增加极大的压力。单纯靠增加存储器容量，提高信道带宽以及计算机的处理速度等方法来解决这个问题是不现实的，这时就要考虑压缩。压缩的关键在于编码，如果在对数据进行编码时，对于常见的数据，编码器输出较短的码字；而对于少见的数据则用较长的码字表示，就能够实现压缩。【例】：假设一个文件中出现了8种符号S0，SQ，S2，S3，S4，S5，S6，S7，那么每种符号要编码，至少需要3bit。假设编码成 000，001， 010，011，100，101，110，111。那么符号序列S0S1S7S0S1S6S2S2S3S4S5S0S0S1编码后变成 000001111000001110010010011100101000000001，共用了42bit。我们发现S0，S1，S2这3个符号出现的频率比较大，其它符号出现的频率比较小，我们采用这样的编码方案：S0到S7的码辽分别01，11，101，0000，0001，0010，0011， 100，那么上述符号序列变成011110001110011101101000000010010010111，共用了39bit。尽管有些码字如 S3，S4，S5，S6变长了(由3位变成4位)，但使用频繁的几个码字如S0，S1变短了，所以实现了压缩。对于上述的编码可能导致解码出现非单值性：比如说，如果S0的码字为01，S2的码字为011，那么当序列中出现011时，你不知道是S0的码字后面跟了个1，还是完整的一个S2的码字。因此，编码必须保证较短的编码决不能是较长编码的前缀。符合这种要求的编码称之为前缀编码。要构造符合这样的二进制编码体系，可以通过二叉树来实现。以下是哈夫曼树的 Java 实现：

[java] view plain copy

// 二叉树节点

public class Node implements Comparable { private int value; private Node leftChild; private Node rightChild; public Node(int value) { this.value = value; } public int getValue() { return value; } public void setValue(int value) { this.value = value; } public Node getLeftChild() { return leftChild; } public void setLeftChild(Node leftChild) { this.leftChild = leftChild; } public Node getRightChild() { return rightChild; } public void setRightChild(Node rightChild) { this.rightChild = rightChild; } public int compareTo(Object o) { Node that = (Node) o; double result = this.value - that.value; return result 0 ? 1 : result == 0 ? 0 : -1; } }

private static Node build(ListNode nodes) {

nodes = new ArrayListNode(nodes);

sortList(nodes);

while (nodes.size() 1) {

createAndReplace(nodes);

}

return nodes.get(0);

}

/**

/**

private static void sortList(ListNode nodes) {

Collections.sort(nodes);

}

`

/**

JAVA 哈夫曼树权值求和（代码找错）

兄弟,你把如下第28行的count++;注释掉,一切问题都可以解决!

自己先琢磨为什么,不懂的再问!

import java.util.Arrays;

import java.util.Scanner;

public class a2 {

public static int n, count = 0;

public static int he[] = new int[n + 1];// 预定义权值数组

public static void Huffman(int[] a) {

Arrays.sort(a);// 排序

// System.out.println(a.length);

if (a.length == 1)// 如果长度是1结束递归

{

he[count++] = a[0];

return;

}

if (a.length == 2)// 如果长度是2结束递归

{

he[count++] = a[0] + a[1];

return;

}

else // 长度大于2

{

int b[] = new int[a.length - 1];// 定义一个新数组，用于保存a

he[count++] = a[0] + a[1];

b[0] = he[--count];// 新数组的第一个元素为当前数组的最小的两个数之和

for (int i = 1; i  b.length; i++)

{

b[i] = a[i + 1];// 赋值除第一个元素之外的值

}

//   count++;

Huffman(b);// 递归

}

}

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

n = Integer.parseInt(sc.nextLine());

String s[] = sc.nextLine().trim().split(" ");// 输入n个数

int d[] = new int[n];

for (int i = 0; i  n; i++)

d[i] = Integer.parseInt(s[i]);// 将String转化为int的数组

Huffman(d);// 递归调用

int sum = 0;

for (int i = 0; i  he.length; i++)

sum += he[i];// 求和

System.out.println(sum);

}

}

我用java构建哈夫曼树的时候报了空指针，代码如下

System.out.println("please input the second letter!");

char ch2 = tw.getChar();

if(ch2 == 'U') {System.out.println("Tuesday"); }

else if(ch2 == 'H') {System.out.println("Thursday"); }