构造哈夫曼树，先序遍历哈夫曼树，计算WPL的值，打印哈夫曼树并释放哈夫曼树的C语言代码

哈夫曼树是一种带权路径长度最短的树，通常用于数据压缩。其构造方法如下：
1. 将所有权值看作一个森林，每个森林都是一个节点，节点的权值为森林中所有节点的权值之和。
2. 从森林中选取两个权值最小的节点组成一棵新树，其权值为这两个节点的权值之和。
3. 将新树插入森林中，并从森林中删除这两个节点。
4. 重复步骤2和步骤3，直到森林中只剩下一个树，即为哈夫曼树。

先序遍历哈夫曼树可以按照以下方式实现：
1. 先输出当前节点的权值。
2. 如果当前节点有左子树，则递归遍历左子树。
3. 如果当前节点有右子树，则递归遍历右子树。

计算WPL（带权路径长度）的值可以按照以下方式实现：
1. 对于每个叶子节点，将其权值乘以其到根节点的路径长度，得到该叶子节点的带权路径长度。
2. 将所有叶子节点的带权路径长度相加，得到WPL的值。

以下是打印哈夫曼树并释放哈夫曼树的C语言代码：

#include <stdio.h>
#include <stdlib.h>

// 哈夫曼树结点
typedef struct HuffmanNode {
    int weight;                     // 权值
    struct HuffmanNode *leftChild;  // 左孩子
    struct HuffmanNode *rightChild; // 右孩子
} HuffmanNode, *HuffmanTree;

// 构建哈夫曼树
void createHuffmanTree(HuffmanTree *tree, int weights[], int n) {
    if (n <= 0) {
        *tree = NULL;
        return;
    }
    // 创建森林
    HuffmanNode **forest = (HuffmanNode **)malloc(sizeof(HuffmanNode *) * n);
    for (int i = 0; i < n; i++) {
        forest[i] = (HuffmanNode *)malloc(sizeof(HuffmanNode));
        forest[i]->weight = weights[i];
        forest[i]->leftChild = NULL;
        forest[i]->rightChild = NULL;
    }
    while (n > 1) {
        // 找到最小的两个结点
        int min1 = 0, min2 = 1;
        if (forest[min1]->weight > forest[min2]->weight) {
            min1 = 1;
            min2 = 0;
        }
        for (int i = 2; i < n; i++) {
            if (forest[i]->weight < forest[min1]->weight) {
                min2 = min1;
                min1 = i;
            } else if (forest[i]->weight < forest[min2]->weight) {
                min2 = i;
            }
        }
        // 合并两个结点
        HuffmanNode *newNode = (HuffmanNode *)malloc(sizeof(HuffmanNode));
        newNode->weight = forest[min1]->weight + forest[min2]->weight;
        newNode->leftChild = forest[min1];
        newNode->rightChild = forest[min2];
        // 将新结点插入森林
        forest[min1] = newNode;
        for (int i = min2; i < n - 1; i++) {
            forest[i] = forest[i + 1];
        }
        n--;
    }
    *tree = forest;
    free(forest);
}

// 先序遍历哈夫曼树
void preorderTraversal(HuffmanTree tree) {
    if (tree != NULL) {
        printf("%d ", tree->weight);
        preorderTraversal(tree->leftChild);
        preorderTraversal(tree->rightChild);
    }
}

// 计算WPL的值
int getWPL(HuffmanTree tree, int depth) {
    if (tree == NULL) {
        return 0;
    } else if (tree->leftChild == NULL && tree->rightChild == NULL) {
        return tree->weight * depth;
    } else {
        return getWPL(tree->leftChild, depth + 1) + getWPL(tree->rightChild, depth + 1);
    }
}

// 打印哈夫曼树
void printHuffmanTree(HuffmanTree tree, int depth) {
    if (tree != NULL) {
        for (int i = 0; i < depth; i++) {
            printf("  ");
        }
        printf("%d\n", tree->weight);
        printHuffmanTree(tree->leftChild, depth + 1);
        printHuffmanTree(tree->rightChild, depth + 1);
    }
}

// 释放哈夫曼树
void destroyHuffmanTree(HuffmanTree tree) {
    if (tree != NULL) {
        destroyHuffmanTree(tree->leftChild);
        destroyHuffmanTree(tree->rightChild);
        free(tree);
    }
}

int main() {
    int weights[] = {3, 4, 5, 6, 7, 8};
    int n = sizeof(weights) / sizeof(int);
    HuffmanTree tree;
    createHuffmanTree(&tree, weights, n);
    printf("先序遍历哈夫曼树：");
    preorderTraversal(tree);
    printf("\n");
    int wpl = getWPL(tree, 0);
    printf("WPL的值：%d\n", wpl);
    printf("打印哈夫曼树：\n");
    printHuffmanTree(tree, 0);
    destroyHuffmanTree(tree);
    return 0;
}