Huffman树创建（基于循序存储）以及基于Huffman树的编码

最新推荐文章于 2022-09-08 22:56:33 发布

Yuliang Feng

最新推荐文章于 2022-09-08 22:56:33 发布

阅读量292

点赞数

分类专栏：数据结构与算法 Java 文章标签： java 数据结构二叉树

本文链接：https://blog.csdn.net/qq_46539113/article/details/109682594

版权

Java 同时被 2 个专栏收录

37 篇文章 2 订阅

订阅专栏

数据结构与算法

16 篇文章 0 订阅

订阅专栏

该博客详细介绍了如何使用哈夫曼树进行数据编码。首先，通过创建基于顺序存储的HuffmanTreeArrayNode类来构建Huffman树，接着利用权重最小的节点合并策略填充树结构。然后，通过遍历树结构生成每个节点的Huffman编码。最后，展示了如何根据构建的Huffman树生成对应的编码映射，以便于高效的数据压缩和传输。

摘要由CSDN通过智能技术生成

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class HuffmanTree<T> {
    private HuffmanTreeArrayNode<T>[] huffmanTree;

    public void createHuffmanTree(List<HuffmanTreeArrayNode<T>> leafNodes){//创建基于顺序存储的Huffman树
        int leafCount = leafNodes.size();
        huffmanTree = new HuffmanTreeArrayNode[2*leafCount-1];
        int treeIndex = 0;
        for (HuffmanTreeArrayNode<T> node: leafNodes) {
            huffmanTree[treeIndex++] = node;
        }
        for (int i = leafCount; i < huffmanTree.length; i++) {
            double min1 , min2;
            min1 = min2 =  Double.MAX_VALUE;
            int min1Index , min2Index;
            min1Index = min2Index = 0;
            for (int j = 0; j < leafCount; j++) {
                if (huffmanTree[j].getParent()==-1){
                    if (huffmanTree[j].getWeight()<min1){
                        min2 = min1;
                        min2Index = min1Index;
                        min1 = huffmanTree[j].getWeight();
                        min1Index = j;
                    }else if (huffmanTree[j].getWeight()<min2){
                        min2 = huffmanTree[j].getWeight();
                        min2Index = j;
                    }
                }
            }
            huffmanTree[min1Index].setParent(leafCount);
            huffmanTree[min2Index].setParent(leafCount);
            huffmanTree[i] = new HuffmanTreeArrayNode<>(min1+min2);
            huffmanTree[i].setLeftChild(min1Index);
            huffmanTree[i].setLeftChild(min2Index);
        }
    }

    public Map<T,String> buildHuffmanCodes(){//基于Huffman树的Huffman编码
        int leafCount = (huffmanTree.length+1)/2;
        Map<T,String> codes = new HashMap<>();
        for (int i = 0; i < leafCount; i++) {
            String code = "";
            int parentIndex = huffmanTree[i].getParent();
            while (parentIndex!=-1){
                if (i == huffmanTree[parentIndex].getLeftChild()){
                    code = 0 + code;
                }else {
                    code = 1 + code;
                }
                parentIndex = huffmanTree[parentIndex].getParent();
            }
            codes.put(huffmanTree[i].getData(),code);
        }
        return codes;
    }
}
class HuffmanTreeArrayNode<T>{
    private T data;
    private double weight;
    private int leftChild = -1;
    private int rightChild = -1;
    private int parent = -1;

    public HuffmanTreeArrayNode(double weight) {
        this.weight = weight;
    }

    public HuffmanTreeArrayNode(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 int getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(int leftChild) {
        this.leftChild = leftChild;
    }

    public int getRightChild() {
        return rightChild;
    }

    public void setRightChild(int rightChild) {
        this.rightChild = rightChild;
    }

    public int getParent() {
        return parent;
    }

    public void setParent(int parent) {
        this.parent = parent;
    }
}