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

好的，这是一个比较复杂的编程任务，需要涉及到Huffman编码的基本原理和算法。下面是一个基本的实现思路：

1. 定义一个结构体来表示Huffman树的节点，包括字符、权值、左右子节点等信息。

typedef struct _huffman_node {
    char ch;  // 字符
    int freq;  // 权值
    struct _huffman_node *left, *right;  // 左右子节点
} huffman_node;

2. 定义一个函数来读取输入的字符串并统计每个字符出现的次数，用于构建Huffman树。

void count_chars(char *str, int *freq) {
    while (*str) {
        freq[*str]++;
        str++;
    }
}

3. 定义一个函数来创建Huffman树。

huffman_node *build_huffman_tree(int *freq) {
    // 创建一个节点数组，用于存放Huffman树的叶子节点
    huffman_node *nodes[256] = {0};
    int i, j, n = 0;
    for (i = 0; i < 256; i++) {
        if (freq[i] > 0) {
            nodes[n] = (huffman_node *) malloc(sizeof(huffman_node));
            nodes[n]->ch = (char) i;
            nodes[n]->freq = freq[i];
            nodes[n]->left = nodes[n]->right = NULL;
            n++;
        }
    }

    // 构建Huffman树
    while (n > 1) {
        // 找到权值最小的两个节点
        huffman_node *min1 = nodes[0];
        huffman_node *min2 = nodes[1];
        if (min1->freq > min2->freq) {
            huffman_node *tmp = min1;
            min1 = min2;
            min2 = tmp;
        }
        for (i = 2; i < n; i++) {
            if (nodes[i]->freq < min1->freq) {
                min2 = min1;
                min1 = nodes[i];
            } else if (nodes[i]->freq < min2->freq) {
                min2 = nodes[i];
            }
        }

        // 创建一个新节点，将权值最小的两个节点作为其左右子节点
        huffman_node *new_node = (huffman_node *) malloc(sizeof(huffman_node));
        new_node->freq = min1->freq + min2->freq;
        new_node->left = min1;
        new_node->right = min2;

        // 将新节点加入节点数组中，删除原来的两个节点
        nodes[n-2] = new_node;
        n--;
        for (i = 0; i < n; i++) {
            if (nodes[i] == min1 || nodes[i] == min2) {
                for (j = i; j < n-1; j++) {
                    nodes[j] = nodes[j+1];
                }
                n--;
                i--;
            }
        }
    }

    return nodes[0];
}

4. 定义一个函数来对Huffman树进行编码。

void encode_huffman_tree(huffman_node *node, char *code, char **codes) {
    if (node == NULL) return;
    if (node->left == NULL && node->right == NULL) {
        codes[node->ch] = strdup(code);
        return;
    }
    code[strlen(code)] = '0';  // 将编码码流加上左分支的 0
    encode_huffman_tree(node->left, code, codes);
    code[strlen(code) - 1] = '1';  // 将编码码流改回上一个状态，加上右分支的 1
    encode_huffman_tree(node->right, code, codes);
    code[strlen(code) - 1] = '\0';  // 回溯到上一个状态
}

5. 定义一个函数来对输入的字符串进行Huffman编码。

char *encode_huffman(char *str, char **codes) {
    char *code = (char *) malloc(sizeof(char) * (strlen(str) * 8 + 1));
    char *p = code;
    while (*str) {
        strcat(p, codes[*str]);
        p += strlen(codes[*str]);
        str++;
    }
    return code;
}

6. 定义一个函数来对Huffman编码后的字符串进行解码。

char *decode_huffman(char *code, huffman_node *root) {
    char *str = (char *) malloc(sizeof(char) * (strlen(code) / 8 + 1));
    char *p = str;
    huffman_node *node = root;
    while (*code) {
        if (*code == '0') node = node->left;
        else node = node->right;
        if (node->left == NULL && node->right == NULL) {
            *p++ = node->ch;
            node = root;
        }
        code++;
    }
    *p = '\0';
    return str;
}

7. 最后在主函数中调用上述函数完成整个过程。

int main() {
    // 读取输入字符串并统计字符出现次数
    char str[1024];
    fgets(str, sizeof(str), stdin);
    int freq[256] = {0};
    count_chars(str, freq);

    // 创建Huffman树并进行编码
    huffman_node *root = build_huffman_tree(freq);
    char *codes[256] = {0};
    char code[256] = "";
    encode_huffman_tree(root, code, codes);
    char *huff_code = encode_huffman(str, codes);
    printf("Huffman Code: %s\n", huff_code);

    // 对编码后的字符串进行解码
    char *decoded_str = decode_huffman(huff_code, root);
    printf("Decoded String: %s\n", decoded_str);

    return 0;
}

注释如下：

- 第1步：定义表示Huffman树节点的结构体，包括字符、权值、左右子节点等信息。
- 第2步：定义一个函数`count_chars`，用于读取输入字符串并统计每个字符出现的次数，用于构建Huffman树。
- 第3步：定义一个函数`build_huffman_tree`，用于构建Huffman树。具体实现过程为：先创建一个节点数组，用于存放Huffman树的叶子节点；然后不断找到权值最小的两个节点，创建一个新节点将它们作为左右子节点，并加入节点数组中，直到只剩下一个节点为止。最后返回根节点。
- 第4步：定义一个函数`encode_huffman_tree`，用于对Huffman树进行编码。具体实现过程为：如果当前节点是叶子节点，将其对应的编码码流加入编码表中；否则，分别对左右子节点进行编码，编码码流加上左分支的0，回溯到上一个状态后加上右分支的1。
- 第5步：定义一个函数`encode_huffman`，用于对输入字符串进行Huffman编码。具体实现过程为：遍历输入字符串中的每个字符，将其对应的编码码流加入编码结果中。
- 第6步：定义一个函数`decode_huffman`，用于对Huffman编码后的字符串进行解码。具体实现过程为：遍历输入字符串中的每个字符，根据0和1分别向左或向右走，直到找到叶子节点，将叶子节点对应的字符加入解码结果中。
- 第7步：在主函数中调用上述函数完成整个过程。