Huffman树

结点定义：

/*
 * Huffman树结点定义
 */
struct Node
{
    ElementType weight;         // 结点的权值
    struct Node *leftChild;     // 结点的左指针
    struct Node *rightChild;    // 结点的右指针
};

根据给定权值数组，构建一个Huffman树：

/*
 * 输出内存申请失败的消息
 */
void showFailureMessage()
{
    printf("Memory allocate failure!
");
    exit(-1);
}

/*
 * 根据数组获取数组的长度
 */
int getArrayLength(ElementType weights[])
{
}

/*
 * 对程序运行中申请的内存空间做事后处理
 */
void destroy(struct Node **)
{
}

/*
 * 为给定权值数组创建一个Huffman树，返回根结点指针
 */
Node * createHuffmanTree(ElementType weights[])
{
    /* 根据传入的数组初始化 */
    int arrayLength = getArrayLength(weights);
    struct Node **nodePointerArray = (struct Node **)malloc(sizeof(struct Node *) * arrayLength);
    if(nodePointerArray == NULL)
        showFailureMessage();
    for(int index = 0; index < arrayLength; ++index) {    // 初始化指针数组nodePointerArray，每个指针指向一个二叉树结点
        nodePointerArray[index] = (struct Node *)malloc(sizeof(struct Node));
        if(nodePointerArray[index] == NULL) 
            showFailureMessage();
        nodePointerArray[index]->weight = weights[index]; // 是树中各结点权值与传入的数组weights中元素一一对应
        nodePointerArray[index]->leftChild = nodePointerArray[index]->rightChild = NULL;
    }

    /* 在初始化基础上进行(数组长度-1)次操作构造Huffman树 */
    struct Node * rootNode = NULL;
    for(int index = 0; index < arrayLength; ++index) {
        /* 找到自index后的最小值和次小值索引 */
        int lowestIndex = index;
        int lowSecondIndex = index + 1;
        for(int innerIndex = lowSecondIndex; innerIndex < arrayLength; ++innerIndex) {
            if(nodePointerArray[innerIndex]->weight < nodePointerArray[lowestIndex]->weight) {
                lowSecondIndex = lowestIndex;
                lowestIndex = innerIndex;
            } else if(nodePointerArray[innerIndex]->weight < nodePointerArray[lowSecondIndex]->weight) {
                lowSecondIndex = innerIndex;
            }
        }
        
        /* 将最小值和次小值所对应的结点(或子树的根结点)生成一颗二叉树 */
        rootNode = (struct Node *)malloc(sizeof(struct Node));
        if(rootNode == NULL)
            showFailureMessage();
        rootNode->weight = nodePointerArray[lowestIndex]->weight + nodePointerArray[lowSecondIndex]->weight;
        rootNode->leftChild = nodePointerArray[lowestIndex];
        rootNode->rightChild = nodePointerArray[lowSecondIndex];

        /* 此次生成二叉树后，对本次循环的索引值、最小值的索引值、次小值的索引值
         * 所对应的结点做事后处理(此处巧用最小值和次小值所在结点需要移除) */
        nodePointerArray[lowestIndex] = rootNode;
        nodePointerArray[lowSecondIndex] = nodePointerArray[index];
        nodePointerArray[index] = NULL;
    }
    destroy(nodePointerArray);

    return rootNode;
}

Huffman树求得树中各字符编码：

/**
 * 由给定的编码Huffman树求得树中各字符编码的算法，并分析器复杂度
 **/
 void HuffmanCode(Node *root, int index)
 {
    static int code[SIZE];                                          // code存放字符编码，其长度等于树的深度
    if(root != NULL) {
        if(root->leftChild == NULL && root->rightChild == NULL) {
            cout << "Weight：" << root->data << " coding：";
            for(int in = 0; in < SIZE; ++in)                        // 输出叶子结点的编码
                cout << code[in];
            count << endl;
        } else {
            code[index] = 0;
            HuffmanCode(root->leftChild, (index + 1));              // 对左子树搜索
            code[index] = 1;
            HuffmanCode(root->rightChild, (index + 1));             // 对右子树搜索
        }
    }
 }

OK哒！O(∩_∩)O哈！