只要自己再加個類Tree就可以了。
創(chuàng)新互聯(lián)專注于旅順口網(wǎng)站建設服務及定制，我們擁有豐富的企業(yè)做網(wǎng)站經(jīng)驗。 熱誠為您提供旅順口營銷型網(wǎng)站建設，旅順口網(wǎng)站制作、旅順口網(wǎng)頁設計、旅順口網(wǎng)站官網(wǎng)定制、微信小程序開發(fā)服務，打造旅順口網(wǎng)絡公司原創(chuàng)品牌,更為您提供旅順口網(wǎng)站排名全網(wǎng)營銷落地服務。
代碼如下：
public class Tree {
double lChild, rChild, parent;
public Tree (double lChild, double rChild, double parent) {
this.lChild = lChild;
this.rChild = rChild;
this.parent = parent;
}
public double getLchild() {
return lChild;
}
public void setLchild(double lChild) {
this.lChild = lChild;
}
public double getRchild() {
return rChild;
}
public void setRchild(double rChild) {
this.rChild = rChild;
}
public double getParents() {
return parent;
}
public void setParents(double root) {
this.parent = root;
}
}
哈夫曼樹是給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優(yōu)二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。
例子：
1、將w1、w2、…，wn看成是有n 棵樹的森林(每棵樹僅有一個結點)；
2、 在森林中選出兩個根結點的權值最小的樹合并，作為一棵新樹的左、右子樹，且新樹的根結點權值為其左、右子樹根結點權值之和；
3、從森林中刪除選取的兩棵樹，并將新樹加入森林；
4、重復(2)、(3)步，直到森林中只剩一棵樹為止，該樹即為所求得的哈夫曼樹。
擴展資料：
按照哈夫曼編碼構思程序流程：
1、切割的順序是從上往下，直至數(shù)組中的元素全部出現(xiàn)在葉節(jié)點；
2、我們思路正好相反，從數(shù)組中找出最小的兩個元素作為最下面的葉節(jié)點，在向備選數(shù)組中存入這兩個葉節(jié)點的和（這個新的和加入累加運算，這個和也就是所求的最小值的一部分，原因如上圖）。
3、以本題為例，備選數(shù)組中現(xiàn)有元素為{30，30}，再次取出兩個最小元素進行求和，得到新的元素，回歸備選數(shù)組并記入累加。
4、上述2.3布重復執(zhí)行直至備選數(shù)組中只有一個元素，此時累加結束，返回累加值即可
5、求數(shù)組中的最小值，可以用小根堆進行提取最為方便；此題用到了貪心的思路，即用相同的策略重復執(zhí)行，直至我們得到所需的結果。
參考資料來源:百度百科——哈夫曼樹
寫給你了，請發(fā)JAVA版塊
package other;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* 定義了一種接口，要進行編碼的最小單元類必需實現(xiàn)些接口
*
*/
interface CombinableT extends ComparableT {
T combinate(T a, T b);
}
/**
*
* the huffman tree Class 哈夫曼樹，包括當前節(jié)點數(shù)據(jù)信息，左節(jié)點，右節(jié)點信息。
*/
class HuffmanTreeT extends CombinableT implements
ComparableHuffmanTreeT {
/** the root of huffman tree */
private T root;
/** the left node of huffman tree */
private HuffmanTreeT left;
/** the right node of huffman tree */
private HuffmanTreeT right;
/** 哈夫曼編碼字符串，如:0000110 */
private String huffmanCodeString = "";
/** 是否對最終生成的哈夫曼進行過編碼操作 */
private static boolean isSettedHuffmanCoderString = false;
public T getRoot() {
return root;
}
public void setRoot(T root) {
this.root = root;
}
public HuffmanTreeT getLeft() {
return left;
}
public void setLeft(HuffmanTreeT left) {
this.left = left;
}
public HuffmanTreeT getRight() {
return right;
}
public void setRight(HuffmanTreeT right) {
this.right = right;
}
/**
*
* 重寫此方法用于遞歸合并節(jié)點后進行排序操作
*
*/
public int compareTo(HuffmanTreeT o) {
return o.getRoot().compareTo(this.getRoot());
}
public String toString() {
return "the root:" + this.getRoot() + "\r\nthe left:" + this.getLeft()
+ "\r\nthe right:" + this.getRight();
}
/**
*
* 對最終生成的樹進行哈夫曼編碼，使每個葉子節(jié)點生成01的路徑編碼
*
*/
private void setHuffmanCoderString() {
HuffmanTreeT left = this.getLeft();
// 如果有左節(jié)點則在路徑中追加"0"
if (left != null) {
left.huffmanCodeString = this.huffmanCodeString + "0";
left.setHuffmanCoderString();// 遞歸編碼
}
HuffmanTreeT right = this.getRight();
// 如果有右節(jié)點則在路徑中追加"1"
if (right != null) {
right.huffmanCodeString = this.huffmanCodeString + "1";
right.setHuffmanCoderString();// 遞歸編碼
}
}
public void printHuffmanCoderString() {
// 打印最終生成樹的哈夫曼編碼前要進行編碼操作，
// 且此操作只執(zhí)行一次，所以用全局標識變量判斷
if (!HuffmanTree.isSettedHuffmanCoderString) {
this.setHuffmanCoderString();
HuffmanTree.isSettedHuffmanCoderString = true;// 標識已執(zhí)行過編碼
}
// 如果是葉子節(jié)點（即要編碼的單元），則打印出編碼信息，如果是非葉子結點（中間臨時生成的節(jié)點），則不打印
if (this.left == null this.right == null)
System.out.println("the " + this.getRoot() + " huffmanCoder:"
+ this.huffmanCodeString);
if (this.left != null)
this.left.printHuffmanCoderString();// 遞歸打印
if (this.right != null)
this.right.printHuffmanCoderString();// 遞歸打印
}
}
/**
*
* 用類用于生成一個哈夫曼樹
*/
class HuffmanTreeFactoryT extends CombinableT {
/** 初始時一個list列表當作要編碼的單元類的容器 */
private ListHuffmanTreeT HuffmanTreeCollection;
/**
*
* @param unitClasses
* 待編碼的單元類集合
*
*/
public HuffmanTreeFactory(ListT unitClasses) {
if (unitClasses == null || unitClasses.size() == 0)
throw new IllegalArgumentException(
"the unit classes collection can't be empty");
HuffmanTreeCollection = new LinkedListHuffmanTreeT();
// 初始化哈夫曼集合容器
for (T unitClass : unitClasses) {
HuffmanTreeT huffmanTree = new HuffmanTreeT();
huffmanTree.setRoot(unitClass);
huffmanTree.setLeft(null);
huffmanTree.setLeft(null);
HuffmanTreeCollection.add(huffmanTree);
}
Collections.sort(HuffmanTreeCollection);
}
/**
* 將待編碼的哈夫曼集合處理成只含有一個元素的集合，則這最后一個元素 即為最終生成的哈夫曼樹
*/
private void generateHuffmanTree() {
while (true) {
if (HuffmanTreeCollection == null
|| HuffmanTreeCollection.size() = 1)
break;
// 處理之前一定要重新排序，這是哈夫曼編碼的關鍵原理
Collections.sort(HuffmanTreeCollection);
HuffmanTreeT huffmanTreeOne = HuffmanTreeCollection.remove(0);
HuffmanTreeT huffmanTreeTwo = HuffmanTreeCollection.remove(0);
HuffmanTreeT huffmanTreeNew = new HuffmanTreeT();
// 將集合中前面兩個元素合并成一個元素插到集合中去
// 并將第一個元素和第二個元素分別作為新元素的左，右節(jié)點
huffmanTreeNew.setRoot(huffmanTreeOne.getRoot().combinate(
huffmanTreeOne.getRoot(), huffmanTreeTwo.getRoot()));
huffmanTreeNew.setLeft(huffmanTreeOne);
huffmanTreeNew.setRight(huffmanTreeTwo);
HuffmanTreeCollection.add(huffmanTreeNew);
}
}
/**
*
*
*
* @return 生成最終的哈夫曼樹
*
*/
public HuffmanTreeT getHuffmanTree() {
generateHuffmanTree();
return this.HuffmanTreeCollection.get(0);
}
}
/**
* 自定義一個用于測試的單元類
*/
class UnitClass implements Serializable, CombinableUnitClass {
/** 出現(xiàn)概率數(shù)據(jù) */
private int rate;
public UnitClass(int rate) {
this.rate = rate;
}
public int getRate() {
return rate;
}
public void setRate(int rate) {
this.rate = rate;
}
/**
* implements thid compartTo() in order to sort the
*
* collection stored from unitclass
*/
public int compareTo(UnitClass o) {
return o.getRate() this.rate ? 1 : o.getRate() this.rate ? -1 : 0;
}
public String toString() {
return "the rate is:" + rate;
}
/**
*
* 重寫此方法用于哈夫曼編碼時可以合并兩個分支點信息
*
*/
public UnitClass combinate(UnitClass a, UnitClass b) {
if (a == null || b == null)
return null;
return new UnitClass(a.getRate() + b.getRate());
}
}
public class Test {
public static int counter(String s, char c) {
int count = 0;
for (int i = 0; i s.length(); i++) {
if (s.charAt(i) == c) {
count++;
}
}
return count;
}
public static void main(String[] args) {
String str = "你好呵呵123abbeab啊";
ListUnitClass l = new ArrayListUnitClass();
for (int i = 0; i str.length(); i++) {
char c = str.charAt(i);
System.out.println(c + "出現(xiàn)了" + counter(str, c) + "次");
l.add(new UnitClass(c));
}
HuffmanTreeFactoryUnitClass factory = new HuffmanTreeFactoryUnitClass(
l);
factory.getHuffmanTree().printHuffmanCoderString();
}
}
重慶分公司
重慶分公司
