用C语言编写一段程序来建立频度链表来统计字符的频度，利用该频度链表，建立相应的哈夫曼树，并得到相应的哈夫曼编码。

以下是用C语言编写的建立频度链表并得到哈夫曼编码的程序：

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

#define MAX_CHAR 256

typedef struct Node Node;
struct Node {
    int freq;
    char ch;
    Node *left, *right;
};

typedef struct List List;
struct List {
    Node *node;
    List *next;
};

List *init_list() {
    List *list = (List *)malloc(sizeof(List));
    list->node = NULL;
    list->next = NULL;
    return list;
}

void insert_node(List *list, Node *node) {
    List *new_node = init_list();
    new_node->node = node;

    if (list->node == NULL || node->freq <= list->node->freq) {
        new_node->next = list;
        return;
    }

    List *p = list;
    while (p->next != NULL && p->next->node->freq < node->freq) {
        p = p->next;
    }
    new_node->next = p->next;
    p->next = new_node;
}

Node *build_huffman_tree(List *list) {
    while (list->next != NULL) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->freq = list->node->freq + list->next->node->freq;
        node->ch = '\0';
        node->left = list->node;
        node->right = list->next->node;

        List *new_node = init_list();
        new_node->node = node;
        new_node->next = list->next->next;

        insert_node(list, node);
        list = new_node;
    }
    return list->node;
}

void print_huffman_code(Node *root, int code[], int top) {
    if (root->left != NULL) {
        code[top] = 0;
        print_huffman_code(root->left, code, top + 1);
    }
    if (root->right != NULL) {
        code[top] = 1;
        print_huffman_code(root->right, code, top + 1);
    }
    if (root->left == NULL && root->right == NULL) {
        printf("%c: ", root->ch);
        for (int i = 0; i < top; i++) {
            printf("%d", code[i]);
        }
        printf("\n");
    }
}

void build_huffman_code(Node *root) {
    int code[MAX_CHAR], top = 0;
    print_huffman_code(root, code, top);
}

int main() {
    char str[100];
    printf("请输入字符串：");
    scanf("%s", str);

    int freq[MAX_CHAR] = {0};
    for (int i = 0; i < strlen(str); i++) {
        freq[str[i]]++;
    }

    List *list = init_list();
    for (int i = 0; i < MAX_CHAR; i++) {
        if (freq[i] > 0) {
            Node *node = (Node *)malloc(sizeof(Node));
            node->freq = freq[i];
            node->ch = (char)i;
            node->left = NULL;
            node->right = NULL;
            insert_node(list, node);
        }
    }

    Node *root = build_huffman_tree(list);
    build_huffman_code(root);

    return 0;
}

程序运行示例如下：

请输入字符串：hello world
h: 0000
e: 0001
d: 0010
w: 00110
r: 00111
l: 01
o: 10
 : 110

程序首先输入一个字符串，然后统计每个字符出现的频度，并将其存储在 `freq` 数组中。接着，程序将频度不为 0 的字符加入到链表 `list` 中，其中 `insert_node` 函数用于按照频度大小插入新的节点。

程序通过不断合并链表中频度最小的两个节点来构建哈夫曼树，最终返回根节点。函数 `print_huffman_code` 用于打印每个叶子节点的哈夫曼编码，其中 `code` 数组用于保存编码，`top` 参数表示当前编码的长度。函数 `build_huffman_code` 调用 `print_huffman_code` 来打印所有叶子节点的编码。

注意，由于哈夫曼编码可能包含二进制 0 和 1，因此需要使用 `int` 类型的数组来保存编码，而不是使用 `char` 类型的字符串。