利用C语言编写完整代码。具体要求为： 从键盘任意输入一个由英文字母带空格构成的文本字符串，例如“I like Learning datastructure course”，首先根据该字符串创建Huffman树，之后进行Huffman编码，然后把该字符串的Huffman编码结果向屏幕输出。能够利用前述的Huffman编码结果对某0-1码流进行解码得到字符串，并做详细注释

好的，根据您的要求，我为您编写了以下代码，可以实现从键盘任意输入一个由英文字母带空格构成的文本字符串，利用 Huffman 编码和解码算法进行编码和解码，并将编码结果输出到屏幕上。

Huffman编码的过程是：首先统计每个字符在输入字符串中出现的频率，然后根据字符频率构建哈夫曼树，接着对哈夫曼树进行遍历，对于每个字符，输出其对应的二进制编码。解码过程是根据哈夫曼树以及编码结果进行逆向遍历，得到原始字符串。

代码如下：

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

// 哈夫曼树节点结构体
typedef struct HuffmanNode {
    char data;  // 节点保存的字符
    int freq;  // 字符出现的频率
    struct HuffmanNode *left, *right;  // 左右子节点
} HuffmanNode;

// 哈夫曼编码结构体
typedef struct HuffmanCode {
    char data;  // 字符
    char *code;  // 对应的哈夫曼编码
} HuffmanCode;

// 统计字符串中每个字符出现的频率
int *countFreq(char *str) {
    int *freq = (int *)calloc(256, sizeof(int));  // 初始化为0
    char *p = str;
    while (*p != '\0') {
        freq[*p++]++;
    }
    return freq;
}

// 创建哈夫曼树
HuffmanNode *createHuffmanTree(char *str) {
    // 统计字符串中每个字符出现的频率
    int *freq = countFreq(str);
    // 创建哈夫曼节点数组
    HuffmanNode **nodes = (HuffmanNode **)malloc(sizeof(HuffmanNode *) * 256);
    int count = 0;
    for (int i = 0; i < 256; i++) {
        if (freq[i] > 0) {
            HuffmanNode *node = (HuffmanNode *)malloc(sizeof(HuffmanNode));
            node->data = (char)i;
            node->freq = freq[i];
            node->left = node->right = NULL;
            nodes[count++] = node;
        }
    }
    free(freq);  // 释放频率统计数组
    // 构建哈夫曼树
    while (count > 1) {
        // 找到频率最小的两个节点
        int min1 = 0, min2 = 1;
        if (nodes[min1]->freq > nodes[min2]->freq) {
            int temp = min1;
            min1 = min2;
            min2 = temp;
        }
        for (int i = 2; i < count; i++) {
            if (nodes[i]->freq < nodes[min1]->freq) {
                min2 = min1;
                min1 = i;
            } else if (nodes[i]->freq < nodes[min2]->freq) {
                min2 = i;
            }
        }
        // 创建新节点
        HuffmanNode *newNode = (HuffmanNode *)malloc(sizeof(HuffmanNode));
        newNode->data = '\0';
        newNode->freq = nodes[min1]->freq + nodes[min2]->freq;
        newNode->left = nodes[min1];
        newNode->right = nodes[min2];
        // 将新节点加入节点数组中
        nodes[min1] = newNode;
        nodes[min2] = nodes[count - 1];
        count--;
    }
    // 返回哈夫曼树的根节点
    return nodes[0];
}

// 释放哈夫曼树的内存
void freeHuffmanTree(HuffmanNode *root) {
    if (root != NULL) {
        freeHuffmanTree(root->left);
        freeHuffmanTree(root->right);
        free(root);
    }
}

// 递归遍历哈夫曼树，生成哈夫曼编码
void generateHuffmanCode(HuffmanNode *root, char *code, int depth, HuffmanCode *huffmanCodes) {
    if (root->left == NULL && root->right == NULL) {
        // 生成哈夫曼编码
        code[depth] = '\0';
        int i;
        for (i = 0; huffmanCodes[i].data != '\0'; i++) {
            if (huffmanCodes[i].data == root->data) {
                huffmanCodes[i].code = (char *)malloc(sizeof(char) * (depth + 1));
                strcpy(huffmanCodes[i].code, code);
                break;
            }
        }
        if (huffmanCodes[i].data == '\0') {
            huffmanCodes[i].data = root->data;
            huffmanCodes[i].code = (char *)malloc(sizeof(char) * (depth + 1));
            strcpy(huffmanCodes[i].code, code);
            huffmanCodes[i + 1].data = '\0';
        }
        return;
    }
    // 递归遍历左右子树
    code[depth] = '0';
    generateHuffmanCode(root->left, code, depth + 1, huffmanCodes);
    code[depth] = '1';
    generateHuffmanCode(root->right, code, depth + 1, huffmanCodes);
}

// 利用哈夫曼编码将字符串进行编码
char *encodeString(char *str, HuffmanCode *huffmanCodes) {
    // 计算编码后字符串的长度
    int len = 0;
    char *p = str;
    while (*p != '\0') {
        for (int i = 0; huffmanCodes[i].data != '\0'; i++) {
            if (*p == huffmanCodes[i].data) {
                len += strlen(huffmanCodes[i].code);
                break;
            }
        }
        p++;
    }
    // 分配空间并进行编码
    char *codeStr = (char *)malloc(sizeof(char) * (len + 1));
    char *q = codeStr;
    p = str;
    while (*p != '\0') {
        for (int i = 0; huffmanCodes[i].data != '\0'; i++) {
            if (*p == huffmanCodes[i].data) {
                strcat(q, huffmanCodes[i].code);
                q += strlen(huffmanCodes[i].code);
                break;
            }
        }
        p++;
    }
    *q = '\0';
    return codeStr;
}

// 利用哈夫曼编码将0-1编码流进行解码
char *decodeString(char *codeStr, HuffmanNode *root) {
    int len = strlen(codeStr);
    char *str = (char *)malloc(sizeof(char) * (len + 1));
    HuffmanNode *p = root;
    char *q = str;
    for (int i = 0; i < len; i++) {
        if (codeStr[i] == '0') {
            p = p->left;
        } else {
            p = p->right;
        }
        if (p->left == NULL && p->right == NULL) {
            *q++ = p->data;
            p = root;
        }
    }
    *q = '\0';
    return str;
}

int main() {
    char str[1000];
    printf("请输入字符串：");
    gets(str);
    // 创建哈夫曼树
    HuffmanNode *root = createHuffmanTree(str);
    // 生成哈夫曼编码
    char code[256];
    HuffmanCode huffmanCodes[256];
    memset(huffmanCodes, 0, sizeof(huffmanCodes));
    generateHuffmanCode(root, code, 0, huffmanCodes);
    // 输出哈夫曼编码表
    printf("字符\t频率\t编码\n");
    for (int i = 0; huffmanCodes[i].data != '\0'; i++) {
        printf("%c\t%d\t%s\n", huffmanCodes[i].data, countFreq(str)[huffmanCodes[i].data], huffmanCodes[i].code);
    }
    // 编码
    char *codeStr = encodeString(str, huffmanCodes);
    printf("编码结果：%s\n", codeStr);
    // 解码
    char *decodeStr = decodeString(codeStr, root);
    printf("解码结果：%s\n", decodeStr);
    // 释放内存
    freeHuffmanTree(root);
    free(codeStr);
    free(decodeStr);
    for (int i = 0; huffmanCodes[i].data != '\0'; i++) {
        free(huffmanCodes[i].code);
    }
    return 0;
}

> 注意：为了简化代码，没有对输入的字符串进行长度限制。实际应用中需要根据具体情况进行限制。