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

好的，这是一个比较复杂的问题，需要涉及到Huffman编码和解码的知识。我会尽力解答你的问题，但是需要您耐心阅读代码和注释。

首先，我们需要定义Huffman树和Huffman编码的相关数据结构。

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

#define MAX_NODE_NUM 256
#define MAX_CODE_LEN 256

typedef struct _HuffmanNode {
    char data;
    int weight;
    struct _HuffmanNode *left;
    struct _HuffmanNode *right;
} HuffmanNode;

typedef struct _HuffmanTree {
    HuffmanNode *root;
} HuffmanTree;

typedef struct _HuffmanCode {
    char data;
    char code[MAX_CODE_LEN];
} HuffmanCode;

其中，`HuffmanNode`表示Huffman树的节点，`HuffmanTree`表示Huffman树，`HuffmanCode`表示Huffman编码结果。

接下来，我们需要实现Huffman树的创建算法。这里我们使用字符出现频率作为权值，来构建Huffman树。

int frequency[MAX_NODE_NUM];

void count_frequency(char *text) {
    memset(frequency, 0, sizeof(frequency));
    int len = strlen(text);
    for (int i = 0; i < len; i++) {
        frequency[(int)text[i]]++;
    }
}

HuffmanNode* create_huffman_node(char data, int weight) {
    HuffmanNode *node = (HuffmanNode*)malloc(sizeof(HuffmanNode));
    node->data = data;
    node->weight = weight;
    node->left = NULL;
    node->right = NULL;
    return node;
}

HuffmanNode* create_huffman_tree(char *text) {
    count_frequency(text);

    HuffmanNode *nodes[MAX_NODE_NUM];
    int node_num = 0;

    for (int i = 0; i < MAX_NODE_NUM; i++) {
        if (frequency[i] > 0) {
            nodes[node_num++] = create_huffman_node(i, frequency[i]);
        }
    }

    while (node_num > 1) {
        int min1 = 0, min2 = 1;
        if (nodes[min1]->weight > nodes[min2]->weight) {
            min1 = 1;
            min2 = 0;
        }

        for (int i = 2; i < node_num; i++) {
            if (nodes[i]->weight < nodes[min1]->weight) {
                min2 = min1;
                min1 = i;
            } else if (nodes[i]->weight < nodes[min2]->weight) {
                min2 = i;
            }
        }

        HuffmanNode *new_node = create_huffman_node('\0', nodes[min1]->weight + nodes[min2]->weight);
        new_node->left = nodes[min1];
        new_node->right = nodes[min2];

        nodes[min1] = new_node;
        nodes[min2] = nodes[--node_num];
    }

    return nodes[0];
}

上述代码中，`count_frequency`函数用于统计字符出现的频率；`create_huffman_node`函数用于创建一个Huffman树的节点；`create_huffman_tree`函数用于根据输入的文本字符串创建Huffman树。

接下来，我们需要实现Huffman编码算法。根据Huffman树的性质，每个字符的Huffman编码可以通过从根节点出发，向左走为0，向右走为1的路径得到。因此，我们可以通过递归的方式遍历整个Huffman树，记录每个字符的Huffman编码。

void traverse_huffman_tree(HuffmanNode *node, char *code, int depth, HuffmanCode *huffman_codes) {
    if (node->left == NULL && node->right == NULL) {
        for (int i = 0; i < strlen(code); i++) {
            huffman_codes[(int)node->data].code[i] = code[i];
        }
        return;
    }

    if (node->left != NULL) {
        code[depth] = '0';
        traverse_huffman_tree(node->left, code, depth + 1, huffman_codes);
    }

    if (node->right != NULL) {
        code[depth] = '1';
        traverse_huffman_tree(node->right, code, depth + 1, huffman_codes);
    }
}

void create_huffman_codes(HuffmanNode *root, HuffmanCode *huffman_codes) {
    char code[MAX_CODE_LEN];
    memset(code, 0, sizeof(code));
    traverse_huffman_tree(root, code, 0, huffman_codes);
}

上述代码中，`traverse_huffman_tree`函数用于遍历整个Huffman树，记录每个字符的Huffman编码；`create_huffman_codes`函数用于创建Huffman编码结果。

最后，我们需要实现Huffman编码和解码的函数。Huffman编码的过程比较简单，只需要根据Huffman编码表将输入的文本字符串转换成二进制编码即可。而Huffman解码的过程比较复杂，需要根据Huffman编码表和二进制编码逐个匹配，还原出原始的文本字符串。

void huffman_encode(char *text, HuffmanCode *huffman_codes) {
    int len = strlen(text);
    for (int i = 0; i < len; i++) {
        printf("%s", huffman_codes[(int)text[i]].code);
    }
}

void huffman_decode(char *code, HuffmanNode *root) {
    HuffmanNode *node = root;
    int len = strlen(code);
    for (int i = 0; i < len; i++) {
        if (code[i] == '0') {
            node = node->left;
        } else {
            node = node->right;
        }

        if (node->left == NULL && node->right == NULL) {
            printf("%c", node->data);
            node = root;
        }
    }
}

上述代码中，`huffman_encode`函数用于对输入的文本字符串进行Huffman编码；`huffman_decode`函数用于对输入的二进制编码进行Huffman解码。

最后，我们可以将上述代码整合到一个完整的程序中，并进行测试。

int main() {
    char text[MAX_NODE_NUM];
    printf("Please input a string:\n");
    fgets(text, MAX_NODE_NUM, stdin);
    text[strlen(text) - 1] = '\0';

    HuffmanNode *root = create_huffman_tree(text);
    HuffmanCode huffman_codes[MAX_NODE_NUM];
    memset(huffman_codes, 0, sizeof(huffman_codes));
    create_huffman_codes(root, huffman_codes);

    printf("Huffman encoding:\n");
    huffman_encode(text, huffman_codes);
    printf("\n");

    char code[MAX_NODE_NUM * MAX_CODE_LEN];
    printf("Please input a binary code:\n");
    fgets(code, MAX_NODE_NUM * MAX_CODE_LEN, stdin);
    code[strlen(code) - 1] = '\0';

    printf("Huffman decoding:\n");
    huffman_decode(code, root);
    printf("\n");

    return 0;
}

这样，我们就完成了对输入的文本字符串进行Huffman编码，并将Huffman编码结果输出到屏幕上。同时，我们还实现了对某个二进制编码进行Huffman解码，并将还原出的文本字符串输出到屏幕上。