贪心算法之哈夫曼编码

哈夫曼编码原理与应用

最新推荐文章于 2023-02-02 15:22:17 发布

weixin_30604651

最新推荐文章于 2023-02-02 15:22:17 发布

阅读量274

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/ttltry-air/archive/2012/07/10/2584790.html

哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。

给出现频率高的字符较短的编码，出现频率较低的字符以较长的编码，可以大大缩短总码长。

定长码：

3*(45+13+12+16+9+5) = 300 千位

变长码：

1*45+3*13+3*12+3*16+4*9+4*5 ＝ 224 千位

1、前缀码

对每一个字符规定一个0,1串作为其代码，并要求任一字符的代码都不是其它字符代码的前缀。这种编码称为前缀码。

编码的前缀性质可以使译码方法非常简单。

表示最优前缀码的二叉树总是一棵完全二叉树，即树中任一结点都有2个儿子结点。

f(c)表示字符c出现的概率，dt(c)表示c的码长

平均码长定义为：

使平均码长达到最小的前缀码编码方案称为给定编码字符集C的最优前缀码。

2、构造哈夫曼编码

哈夫曼提出构造最优前缀码的贪心算法，由此产生的编码方案称为哈夫曼编码。

哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。

算法以|C|个叶结点开始，执行|C|－1次的“合并”运算后产生最终所要求的树T。

以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。一旦2棵具有最小频率的树合并后，产生一棵新的树，其频率为合并的2棵树的频率之和，并将新树插入优先队列Q。经过n－1次的合并后，优先队列中只剩下一棵树，即所要求的树T。

算法huffmanTree用最小堆实现优先队列Q。初始化优先队列需要O(n)计算时间，由于最小堆的removeMin和put运算均需O(logn)时间，n－1次的合并总共需要O(nlogn)计算时间。因此，关于n个字符的哈夫曼算法的计算时间为O(nlogn) 。

3、哈夫曼算法的正确性

要证明哈夫曼算法的正确性，只要证明最优前缀码问题具有贪心选择性质和最优子结构性质。

(1)贪心选择性质

(2)最优子结构性质

具体代码实现：

 
import java.util.LinkedHashMap; 
import java.util.ArrayList; 
import java.util.Set; 
import java.util.Iterator; 
   
class HuffmanNode { 
    char label; 
    int weight; 
    int parent; 
    int lChild; 
    int rChild; 
    int frequency;//频率主要是用来衡量字符在给定编码字符串中出现的次数 
   
    public HuffmanNode(char label, int weight, int parent, int lChild, 
            int rChild) { 
        this.label = label; 
        this.weight = weight; 
        this.lChild = lChild; 
        this.rChild = rChild; 
    } 
} 
   
class HuffmanTree { 
    private LinkedHashMap<Character, Integer> charTable; //主要用hashmap来存放字符及其出现的频率 
    private Set<Character> charset; 
    private ArrayList<HuffmanNode> huffmanTree;//huffman节点集合 
    private ArrayList<String> huffmanCode;//huffman编码集合 
   
    public HuffmanTree(LinkedHashMap<Character, Integer> map) { 
        charTable = map; 
        charset = map.keySet(); 
        creatHuffmanTree();//首先创建huffman树 
        creatHuffmanCode(); 
    } 
   
    private void initTree() { 
        huffmanTree = new ArrayList<HuffmanNode>(); 
        Iterator<Character> charIter = charset.iterator(); 
        int i = 1; 
        huffmanTree.add(0, 
                new HuffmanNode((char) 0, Integer.MAX_VALUE, 0, 0, 0)); 
        while (charIter.hasNext()) { 
            Character ch = charIter.next(); 
            huffmanTree.add(i, new HuffmanNode(ch, charTable.get(ch), 0, 0, 0)); 
            i++; 
        } 
        for (int j = charset.size() + 1; j < 2 * charset.size(); j++) { 
            huffmanTree.add(j, new HuffmanNode((char) 0, 0, 0, 0, 0)); 
        } 
    } 
     
    // 创建huffman树 
    private void creatHuffmanTree() { 
        initTree(); 
        int min_child1; 
        int min_child2; 
        for (int i = charset.size() + 1; i < 2 * charset.size(); i++) { 
            min_child1 = 0; 
            min_child2 = 0; 
            for (int j = 1; j < i; j++) { 
                if (huffmanTree.get(j).parent == 0) { 
                    if (huffmanTree.get(j).weight < huffmanTree.get(min_child1).weight 
                            || huffmanTree.get(j).weight < huffmanTree 
                                    .get(min_child2).weight) { 
                        if (huffmanTree.get(min_child1).weight < huffmanTree 
                                .get(min_child2).weight) { 
                            min_child2 = j; 
                        } else { 
                            min_child1 = j; 
                        } 
                    } 
                } 
            } 
            huffmanTree.get(min_child1).parent = i; 
            huffmanTree.get(min_child2).parent = i; 
   
            if (min_child1 < min_child2) { 
                huffmanTree.get(i).lChild = min_child1; 
                huffmanTree.get(i).rChild = min_child2; 
            } else { 
                huffmanTree.get(i).rChild = min_child1; 
                huffmanTree.get(i).lChild = min_child2; 
            } 
   
            huffmanTree.get(i).weight = huffmanTree.get(i).weight 
                    + huffmanTree.get(i).weight; 
        } 
    } 
   
    private void creatHuffmanCode() { 
        huffmanCode = new ArrayList<String>(charset.size() + 1); 
        huffmanCode.add(0, null); 
        char[] tempChars = new char[charset.size() + 1]; 
        for (int i = 1; i < charset.size() + 1; i++) { 
            int startIndex = charset.size(); 
            int parent = huffmanTree.get(i).parent; 
            int ch = i; 
            while (parent != 0) { 
                if (huffmanTree.get(parent).lChild == ch) { 
                    tempChars[startIndex] = '0'; 
                } else { 
                    tempChars[startIndex] = '1'; 
                } 
                startIndex--; 
                ch = parent; 
                parent = huffmanTree.get(parent).parent; 
            } 
            System.out.println(String.valueOf(tempChars, startIndex + 1, 
                    charset.size() - startIndex)); 
            huffmanCode.add(i, String.valueOf(tempChars, startIndex + 1, 
                    charset.size() - startIndex)); 
        } 
    }// end method 
     
    // huffman编码 
    public String enCodeString(String inString) { 
        StringBuffer temp = new StringBuffer(); 
        for (int i = 0; i < inString.length(); i++) { 
            int ch = inString.charAt(i); 
            int j = 1; 
            for (; huffmanTree.get(j).label != ch && j < charset.size() + 1; j++) { 
            } 
            if (j <= charset.size()) { 
                temp.append(huffmanCode.get(j)); 
            } else { 
                temp.append(ch); 
            } 
        } 
        return temp.toString(); 
    } 
   
    // huffman解码 
    public String deCodeString(String inString) { 
        StringBuffer temp = new StringBuffer(); 
        int root = charset.size() * 2 - 1; 
        for (int i = 0; i < inString.length(); i++) { 
            char ch = inString.charAt(i); 
            if (ch == '0') { 
                root = huffmanTree.get(root).lChild; 
            } else if (ch == '1') { 
                root = huffmanTree.get(root).rChild; 
            } else { 
                temp.append(ch); 
            } 
            if (root <= charset.size()) { 
                temp.append(huffmanTree.get(root).label); 
                root = charset.size() * 2 - 1; 
            } 
        } 
        return temp.toString(); 
    } 
   
} 
   
public class HuffmanTreeTest { 
    public static void main(String[] args) { 
        LinkedHashMap<Character, Integer> hasmap = new LinkedHashMap<Character, Integer>(); 
        hasmap.put('a', 4); 
        hasmap.put('b', 5); 
        hasmap.put('c', 8); 
        hasmap.put('d', 10); 
   
        HuffmanTree huffman = new HuffmanTree(hasmap); 
        String temp = huffman.enCodeString("abcd"); 
        System.out.println(temp); 
        System.out.println(huffman.deCodeString(temp)); 
   
    } 
   
} 
  