给定权值5,29,7,8,14,23,3,11，建立哈夫曼树，输出哈夫曼编码。然后对上述给定的哈夫曼树及得到的哈夫曼编码，试输入一串二进制编码，输出它的哈夫曼译码。（要求C语言详细代码）

建立哈夫曼树的步骤如下：

1. 将所有权值作为叶子节点，构建森林。
2. 从森林中选出两个权值最小的节点作为新的节点，将这两个节点从森林中移除，并将新节点加入森林。
3. 重复步骤2，直到森林中只剩下一个节点，即为哈夫曼树的根节点。

在这个例子中，我们可以按照以下步骤构建哈夫曼树：

1. 将所有权值作为叶子节点构建森林：

2. 选出权值为3和5的节点，构建新节点8，将3和5从森林中移除并将新节点8加入森林：

3. 选出权值为7和8的节点，构建新节点15，将7和8从森林中移除并将新节点15加入森林：

4. 选出权值为11和14的节点，构建新节点25，将11和14从森林中移除并将新节点25加入森林：

5. 选出权值为15和23的节点，构建新节点38，将15和23从森林中移除并将新节点38加入森林：

6. 选出权值为25和29的节点，构建新节点54，将25和29从森林中移除并将新节点54加入森林：

7. 最终，森林中只剩下一个节点，即为哈夫曼树的根节点，权值为54：

输出哈夫曼编码的步骤如下：

1. 从根节点开始，遍历哈夫曼树。
2. 遇到左子节点则输出0，遇到右子节点则输出1。

在这个例子中，我们可以按照以下步骤输出哈夫曼编码：

1. 从根节点开始，遇到左子节点3，则输出0。
2. 继续遍历，遇到左子节点5，则输出0。
3. 继续遍历，遇到新节点8，则停止。
4. 从根节点开始，遇到左子节点7，则输出0。
5. 继续遍历，遇到新节点15，则停止。
6. 从根节点开始，遇到右子节点23，则输出1。
7. 继续遍历，遇到右子节点29，则输出1。
8. 继续遍历，遇到新节点54，则停止。
9. 最终得到的编码为： 0 0 1 1 1 0 1 0 1 0 1 1 0

对二进制编码进行哈夫曼译码的步骤如下：

1. 从根节点开始，遍历哈夫曼树。
2. 遇到0则进入左子节点，遇到1则进入右子节点。
3. 如果到达叶子节点，则输出该节点的权值，并回到根节点继续遍历。

C语言代码实现如下：

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

#define MAX_NODE 100

typedef struct huffman_tree_node {
    int weight;
    int parent;
    int left_child;
    int right_child;
} huffman_tree_node;

void huffman_tree_init(huffman_tree_node *tree, int *weights, int n)
{
    int i;
    for (i = 0; i < n; i++) {
        tree[i].weight = weights[i];
        tree[i].parent = -1;
        tree[i].left_child = -1;
        tree[i].right_child = -1;
    }
}

void huffman_tree_build(huffman_tree_node *tree, int n)
{
    int i, j, k;
    int min1, min2;
    for (i = n; i < 2 * n - 1; i++) {
        min1 = min2 = -1;
        for (j = 0; j < i; j++) {
            if (tree[j].parent == -1) {
                if (min1 == -1 || tree[j].weight < tree[min1].weight) {
                    min2 = min1;
                    min1 = j;
                } else if (min2 == -1 || tree[j].weight < tree[min2].weight) {
                    min2 = j;
                }
            }
        }
        tree[i].weight = tree[min1].weight + tree[min2].weight;
        tree[i].left_child = min1;
        tree[i].right_child = min2;
        tree[min1].parent = i;
        tree[min2].parent = i;
    }
}

void huffman_tree_encode(huffman_tree_node *tree, int n)
{
    int i, j;
    int code[MAX_NODE];
    int parent, child;
    for (i = 0; i < n; i++) {
        j = 0;
        child = i;
        parent = tree[child].parent;
        while (parent != -1) {
            if (tree[parent].left_child == child) {
                code[j++] = 0;
            } else {
                code[j++] = 1;
            }
            child = parent;
            parent = tree[child].parent;
        }
        printf("Weight %d: ", tree[i].weight);
        while (j--) {
            printf("%d", code[j]);
        }
        printf("\n");
    }
}

void huffman_tree_decode(huffman_tree_node *tree, int n, int code[], int m)
{
    int i, j;
    int p = 2 * n - 2;
    for (i = 0; i < m; i++) {
        if (code[i] == 0) {
            p = tree[p].left_child;
        } else {
            p = tree[p].right_child;
        }
        if (tree[p].left_child == -1 && tree[p].right_child == -1) {
            printf("%d ", tree[p].weight);
            p = 2 * n - 2;
        }
    }
    printf("\n");
}

int main()
{
    int n = 8;
    int weights[] = {5, 29, 7, 8, 14, 23, 3, 11};
    huffman_tree_node tree[MAX_NODE];
    huffman_tree_init(tree, weights, n);
    huffman_tree_build(tree, n);
    huffman_tree_encode(tree, n);
    int code[] = {0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0};
    int m = sizeof(code) / sizeof(code[0]);
    huffman_tree_decode(tree, n, code, m);
    return 0;
}