2. 程式人生 > >Java實現哈夫曼編碼和解碼

Java實現哈夫曼編碼和解碼

阿新 • • 發佈：2019-02-13

題目：將一個字串進行哈夫曼編碼；編碼過程中，會得到每個字元的編碼，通過已知的每個字元的編碼對之前的編碼進行解碼。

分析：

首先是哈夫曼編碼演算法，引用李澤年寫的《多媒體技術教程》中對哈夫曼編碼演算法的描述：

•Initialization: Put all symbols on a list sorted according to their frequency counts. •Repeat until the list has only one symbol left: –From the list pick two symbols with the lowest frequency counts. Form a Huffman subtree that has these two symbols as child nodes and create a parent node.
 –Assign the sum of the children's frequency counts to the parent and insert it into the list such that the order is maintained. –Delete the children from the list. •Assign a code word for each leaf based on the path from the root. 我的程式碼是基於這段演算法描述實現的。實際上，我看的是中文版，但是沒有找到該書的中文電子版，只好把英文版粘過來了。不過，好在英文版的也不復雜。

接下來是解碼。雖然解碼過程很簡單，但是卻是本文存在的理由。我在網上看了一些文章，都忽略一個問題：編碼和解碼過程中都有的東西是什麼？也就是，依靠什麼東西來解碼？本文的答案是“每個字元的編碼”，它在編碼的過程中生成，和字串編碼一起傳到解碼端用於解碼。你也可以說是“每個字元出現的次數”或者“哈夫曼樹”，不管是“每個字元出現的次數”還是“哈夫曼樹”，你都需要通過他們得到“每個字元的編碼”之後才能進行解碼。

下面是Java程式碼：

package com.liyuncong.algorithms.algorithms_huffman;

/**
 * 哈夫曼樹的節點
 * @author yuncong
 *
 */
public class Node implements Comparable<Node>{
    private Node leftChild = null;
    private Data data = null;
    private Node rightChild = null;
    
    public Node getLeftChild() {
        return leftChild;
    }
    public void setLeftChild(Node leftChild) {
        this.leftChild = leftChild;
    }
    public Data getData() {
        return data;
    }
    public void setData(Data data) {
        this.data = data;
    }
    public Node getRightChild() {
        return rightChild;
    }
    public void setRightChild(Node rightChild) {
        this.rightChild = rightChild;
    }
    @Override
    public String toString() {
        return "Node [leftChild=" + leftChild + ", data=" + data
                + ", rightChild=" + rightChild + "]";
    }
    @Override
    public int compareTo(Node o) {
        return this.data.compareTo(o.getData());
    }
    
}


 

package com.liyuncong.algorithms.algorithms_huffman;

/**
 * Data用於儲存一個字元及其出現的次數
 * @author yuncong
 *
 */
public class Data implements Comparable<Data>{
    // 字元
    private char c = 0;
    // 字元出現的次數
    private int frequency = 0;
    
    public char getC() {
        return c;
    }
    public void setC(char c) {
        this.c = c;
    }
    public int getFrequency() {
        return frequency;
    }
    public void setFrequency(int frequency) {
        this.frequency = frequency;
    }
    
    @Override
    public String toString() {
        return "Data [c=" + c + ", frequency=" + frequency + "]";
    }
    @Override
    public int compareTo(Data o) {
        if (this.frequency < o.getFrequency()) {
            return -1;
        } else if (this.frequency > o.getFrequency()) {
            return 1;
        } else {
            return 0;
        }
    }
    
    
}




package com.liyuncong.algorithms.algorithms_huffman;

import java.util.Map;

/**
 * 對字串編碼後的結果：包括編碼後的字串和字元/編碼對
 * @author yuncong
 *
 */
public class EncodeResult {
    // 字串編碼後的結果
    private String encode;
    // 字元編碼對
    private Map<Character, String> letterCode;
    public EncodeResult(String encode, Map<Character, String> letterCode) {
        super();
        this.encode = encode;
        this.letterCode = letterCode;
    }
    public String getEncode() {
        return encode;
    }
    public Map<Character, String> getLetterCode() {
        return letterCode;
    }
}



package com.liyuncong.algorithms.algorithms_huffman;

public interface HuffmanAlgorithm {
    /**
     * 編碼字串。
     * @param str 指定的需要編碼的字串
     * @return 編碼結果
     */
    public EncodeResult encode(String str);
    /**
     * 根據編碼結果返回原來的字串。
     * @param decodeResult 原來字串的編碼結果。
     * @return 解碼出來的字串。
     */
    public String decode(EncodeResult encodeResult);
}


package com.liyuncong.algorithms.algorithms_huffman;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.liyuncong.application.commontools.FileTools;

public abstract class HuffmanAlgorithmAbstract implements HuffmanAlgorithm {
    @Override
    public EncodeResult encode(String str) {
        ArrayList<Node> letterList = toList(str);
        Node rootNode = createTree(letterList);
        Map<Character, String> letterCode = getLetterCode(rootNode);
        EncodeResult result = encode(letterCode, str);
        return result;
    }
    
    /**
     * 把一個字串轉化為節點列表
     * @param letters
     * @return
     */
    private ArrayList<Node> toList(String letters) {
        ArrayList<Node> letterList = new ArrayList<Node>();
        Map<Character, Integer> ci = new HashMap<Character, Integer>();
        for (int i = 0; i < letters.length(); i++) {
            Character character = letters.charAt(i);
            if (!ci.keySet().contains(character)) {
                ci.put(character, 1);
            } else {
                Integer oldValue = ci.get(character);
                ci.put(character, oldValue + 1);
            }
        }
        Set<Character> keys = ci.keySet();
        for (Character key : keys) {
            Node node = new Node();
            Data data = new Data();
            data.setC(key);
            data.setFrequency(ci.get(key));
            node.setData(data);
            letterList.add(node);
        }
        return letterList;
    }
    
    protected abstract Node createTree(ArrayList<Node> letterList);
    
    /**
     * 編碼字串。
     * @param letterCode 字元/編碼對集合。
     * @param letters 指定的需要編碼的字串。
     * @return 編碼結果
     */
    private EncodeResult encode(Map<Character, String> letterCode, String letters) {
        StringBuilder encode = new StringBuilder();
        for (int i = 0, length = letters.length(); i < length; i++) {
            Character character = letters.charAt(i);
            encode.append(letterCode.get(character));
        }
        EncodeResult result = new EncodeResult(encode.toString(), letterCode);
        return result;
    }
    
    /**
     * 獲得所有字元編碼對
     * 
     * @param rootNode哈夫曼樹的根節點
     * @return 所有字元編碼對
     */
    private Map<Character, String> getLetterCode(Node rootNode) {
        Map<Character, String> letterCode = new HashMap<Character, String>();
        // 處理只有一個節點的情況
        if (rootNode.getLeftChild() == null && rootNode.getRightChild() == null) {
            letterCode.put(rootNode.getData().getC(), "1");
            return letterCode;

        }
        getLetterCode(rootNode, "", letterCode);
        return letterCode;
    }

    /**
     * 先序遍歷哈夫曼樹,獲得所有字元編碼對。
     * 
     * @param rooNode 哈夫曼樹根結點
     * @param suffix 編碼字首，也就是編碼這個字元時，之前路徑上的所有編碼
     * @param letterCode 用於儲存字元編碼結果
     */
    private void getLetterCode(Node rooNode, String suffix,
            Map<Character, String> letterCode) {
        if (rooNode != null) {
            if (rooNode.getLeftChild() == null
                    && rooNode.getRightChild() == null) {
                Character character = rooNode.getData().getC();
                letterCode.put(character, suffix);

            }
            getLetterCode(rooNode.getLeftChild(), suffix + "0", letterCode);
            getLetterCode(rooNode.getRightChild(), suffix + "1", letterCode);

        }
    }
    
    public String decode(EncodeResult decodeResult) {
        // 解碼得到的字串
        StringBuffer decodeStr = new StringBuffer();
        // 獲得解碼器
        Map<String, Character> decodeMap = getDecoder(decodeResult
                .getLetterCode());
        // 解碼器鍵集合
        Set<String> keys = decodeMap.keySet();
        // 待解碼的（被編碼的）字串
        String encode = decodeResult.getEncode();
        // 從最短的開始匹配之所以能夠成功，是因為哈夫曼編碼的唯一字首性質
        // 臨時的可能的鍵值
        String temp = "";
        // 改變temp值大小的遊標
        int i = 1;
        while (encode.length() > 0) {
            temp = encode.substring(0, i);
            if (keys.contains(temp)) {
                Character character = decodeMap.get(temp);
                decodeStr.append(character);
                encode = encode.substring(i);
                i = 1;
            } else {
                i++;
            }
        }
        return decodeStr.toString();
    }

    /**
     * 獲得解碼器，也就是通過字母/編碼對得到編碼/字元對。
     * 
     * @param letterCode
     * @return
     */
    private Map<String, Character> getDecoder(Map<Character, String> letterCode) {
        Map<String, Character> decodeMap = new HashMap<String, Character>();
        Set<Character> keys = letterCode.keySet();
        for (Character key : keys) {
            String value = letterCode.get(key);
            decodeMap.put(value, key);
        }
        return decodeMap;
    }
}



package com.liyuncong.algorithms.algorithms_huffman;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 演算法實現參考《多媒體技術教程》
 * @author yuncong
 *
 */
public class HuffmanAlgorithmImpl1 extends HuffmanAlgorithmAbstract {
	
	/*
	 * 建立哈夫曼樹； 丟失了letterList中的資料，深拷貝letterList是需要完善的地方
	 */
	@Override
	protected Node createTree(ArrayList<Node> letterList) {
		init(letterList);
		while (letterList.size() != 1) {
			int size = letterList.size();
			// 小的節點放在右邊（眼睛看到的左邊）
			Node nodeLeft = letterList.get(size - 1);
			Node nodeRight = letterList.get(size - 2);
			Node nodeParent = new Node();
			nodeParent.setLeftChild(nodeLeft);
			nodeParent.setRightChild(nodeRight);
			Data data = new Data();
			data.setFrequency(nodeRight.getData().getFrequency()
					+ nodeLeft.getData().getFrequency());
			nodeParent.setData(data);
			letterList.set(size - 2, nodeParent);
			letterList.remove(size - 1);
			sort(letterList);

		}
		Node rootNode = letterList.get(0);
		return rootNode;
	}
	
	/**
	 * 初始化 讓節點列表有序
	 */
	private void init(ArrayList<Node> letterList) {
		sort(letterList);
	}

	/**
	 * 氣泡排序，把小的放在最後
	 */
	private void sort(ArrayList<Node> letterList) {
		int size = letterList.size();
		// 處理只有一個元素的情況，也就是說，不需要排序
		if (size == 1) {
			return;
		}
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size - 1 - i; j++) {
				if (letterList.get(j).getData().getFrequency() < letterList
						.get(j + 1).getData().getFrequency()) {
					Node tempNode = letterList.get(j);
					letterList.set(j, letterList.get(j + 1));
					letterList.set(j + 1, tempNode);

				}
			}
		}
	}

}



package com.liyuncong.algorithms.algorithms_huffman;

import static org.junit.Assert.*;

import org.junit.Test;

public class HuffmanAlgorithmImpl1Test {

	@Test
	public void testEncodeString() {
		HuffmanAlgorithmImpl1 huffmanImpl1 = new HuffmanAlgorithmImpl1();
		EncodeResult result = huffmanImpl1.encode("abcdda");
		System.out.println(result.getEncode());
	}

	@Test
	public void testDecode() {
		HuffmanAlgorithmImpl1 huffmanImpl1 = new HuffmanAlgorithmImpl1();
		EncodeResult result = huffmanImpl1.encode("abcdda");
		String decode = huffmanImpl1.decode(result);
		System.out.println(decode);
	}


}

原始碼放在github上：

相關推薦

Java實現哈夫曼編碼和解碼

題目：將一個字串進行哈夫曼編碼；編碼過程中，會得到每個字元的編碼，通過已知的每個字元的編碼對之前的編碼進行解碼。 分析： 首先是哈夫曼編碼演算法，引用李澤年寫的《多媒體技術教程》中對哈夫曼編碼演算法的描述： •Initialization: Put all symbols

哈夫曼樹及哈夫曼編碼和解碼

哈夫曼樹，又稱最優樹，是帶權路徑最小的樹。 基本概念： 節點間的路徑長度：兩個節點間所包含的邊的數目。 樹的路徑長度：從根到樹中任意節點的路徑長度之和。 權：將節點賦予一定的量值，該量值成為權。 樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度。 哈夫曼演算法：給定一個儲存權值的陣列，求

java實現哈夫曼編碼

哈夫曼演算法 眾所周知，哈夫曼演算法適用於檔案壓縮領域。由於上機需要，就寫了一個Java程式碼實現。 哈夫曼演算法的內容 1.將帶有符號的字母儲存為葉子節點，其權值為符號出現的次數 2.從這些葉子結點中找到權值最小的兩個節點，然後將其合併成一個新節點

java使用優先級隊列實現哈夫曼編碼

哈夫曼編碼 左右 integer string enc ash 小根堆 rac sta 思路： 構建小根堆 根據小根堆實現哈夫曼樹 根據哈夫曼樹對數據進行編碼 代碼實現如下： /** * @Author: DaleyZou * @Description: 使用jav

最小堆實現哈夫曼樹的構造及哈夫曼編碼、解碼

      以下程式的演算法思想主要來自於浙江大學陳越老師主編的資料結構一書。最大堆（最小堆思想差不多）（之後會寫一篇部落格介紹），這裡主要講講哈夫曼樹的定義及實現。 Huffman Tree 相關概念： 結點的路徑長度：從根結點到該結點的路徑上分支的數

Java如何實現哈夫曼編碼

哈夫曼樹 既然是學習哈夫曼編碼，我們首先需要知道什麼是哈夫曼樹：給定n個權值作為n個葉子結點，構造一棵二叉樹，若帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。   哈夫曼編碼

資料結構之---C語言實現哈夫曼樹和編碼

//哈夫曼樹 //楊鑫 #include <stdio.h> #include <stdlib.h> typedef int ElemType; struct BTreeNode { ElemType data; struct BTr

java使用優先順序佇列實現哈夫曼編碼

思路： 構建小根堆 根據小根堆實現哈夫曼樹 根據哈夫曼樹對資料進行編碼 程式碼實現如下： /** * @Author: DaleyZou * @Description: 使用java實現一個哈夫

哈夫曼編碼和譯碼&&c++重點知識的應用

哈夫曼編碼和譯碼。將以前學的c++相關知識系統的用了一遍，反正是能想到啥，啥方便就用啥，但是說回來，也沒省多少事。反正比用c語言寫跟簡單一點。 先看題目原型吧！ 假設某通訊報文的字符集由A,B,C,D,E,F這6個字元組成，它們在報文中出現的頻度（頻度均為整數值）。 (1)構造一棵哈弗曼

C++實現哈夫曼編碼--使用哈夫曼編碼樹壓縮和解壓縮

      壓縮就是位域的操作，假設A對應0000，B對應1111，則AB壓縮後為00001111即為0x0F，AB原本為2個位元組，壓縮後變為1個位元組。其它資料類似一樣的壓縮操作即可。       解壓縮就是取出每一個位，如果是0，則走到哈夫曼編碼樹的左孩子，如果是1，

用陣列實現哈夫曼編碼

昨天我們班了一場小型的c++資料結構考試，然後博主平時上課也算認真學了吧，但是課後卻沒有去及時鞏固，複習。有許多程式碼當時能敲出來，卻因為缺乏重複的練習，因此敲程式碼的速度特別慢，而且許多地方都有一些bug。導致昨天有個很簡單的huffman編碼的問題我都沒有解決。所以，今天

哈夫曼編碼及其解碼全過程

今年的小學期我選了做哈夫曼編碼，老師的要求是這樣的： 編—譯碼系統的設計 內容： （1） 讀入待編碼的文字，統計各字元出現的頻率 （2） 構造哈夫曼樹 （3） 得到各字元的哈夫曼編碼 （4） 對原文進行編碼 （5） 傳送、接收 （6） 還原（譯碼）收到的文

c語言實現哈夫曼編碼

#include <stdio.h>#include <math.h>#define MAX 100#define MAXSYMBS 30#define MAXNODE 59#define DEEP 10 typedef struct{ float w

C++實現哈夫曼編碼--構建哈夫曼編碼樹

     哈夫曼編碼分為動態和靜態之分。靜態哈夫曼編碼需要統計和計算每個欄位的權重（比如文字'A'字母出現的次數），效率會很低，特別是壓縮大檔案，基本是不現實的。只是，理解靜態哈夫曼編碼是基礎，理解壓縮和解壓思想。     本文使所使用的演算法和構建思路跟我們通常的資料結構

Java理解實現哈夫曼樹以其編碼解碼

哈夫曼樹以其編碼解碼 要求： 1.從終端讀入字符集大小為n（即字元的個數），逐一輸入n個字元和相應的n個權值（即字元出現的頻度），建立哈夫曼樹，進行編碼並且輸出。 將它存於檔案hfmtree中（選做）。 2.利用已建好的哈夫曼編碼檔案hfmtree，對鍵盤輸入的正文進行譯碼。輸出字元正文

哈夫曼編碼(Huffman coding)的那些事,(編碼技術介紹和程序實現)

信號 truct 依次 while 交換 需要 .text 示例 system 前言 　　哈夫曼編碼(Huffman coding)是一種可變長的前綴碼。哈夫曼編碼使用的算法是David A. Huffman還是在MIT的學生時提出的，並且在1952年發表了名為《

哈夫曼編碼解碼 C++實現

錯誤 urn using 過程 簡單 cin n) struct ren 哈夫曼編碼是一個通過哈夫曼樹進行的一種編碼，一般情況下，以字符：‘0’與‘1’表示。編碼的實現過程很簡單，只要實現哈夫曼樹，通過遍歷哈夫曼樹，這裏我們從每一個葉子結點開始向上遍歷，如果該結點為父節點的

轉載：哈夫曼樹的構造和哈夫曼編碼（C++代碼實現）

作者 pos blank 字符 element start man null == 作者：qiqifanqi 原文：http://blog.csdn.net/qiqifanqi/article/details/6038822 #include<stdio.h>

貪心演算法--哈夫曼編碼（java實現 ）

package org.orithmetic.greedySelector; public class Node<T> implements Comparable<Node<T>>{          private T data;   

java 二叉樹（十三） 哈夫曼樹和哈夫曼編碼

一般可以按下面步驟構建： 1，將所有左，右子樹都為空的作為根節點。 2，在森林中選出兩棵根節點的權值最小的樹作為一棵新樹的左，右子樹，且置新樹的附加根節點的權值為其左，右子樹上根節點的權值之和。注意，左子樹的權值應小於右子樹的權值。 3，從森林中刪除這兩棵樹，同時把新樹加入