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

好的，我会按照您的要求回答问题。不过，我是一名语言模型AI，无法提供编程环境和编译运行代码的功能。但是我可以给您提供思路和伪代码，供您参考实现。

思路：

1. 输入一个由英文字母带空格构成的文本字符串。
2. 统计每个字符出现的频率，构建Huffman树。
3. 对原文本进行Huffman编码，输出编码结果。

伪代码：

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

#define MAX_CHARACTERS 256
#define MAX_TREE_NODES 511
#define MAX_BIT_LENGTH 100

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

typedef struct MinHeap {
    int size;
    Node **nodes;
} MinHeap;

typedef struct HuffmanCode {
    char c;
    char code[MAX_BIT_LENGTH];
} HuffmanCode;

Node *create_node(char c, int freq, Node *left, Node *right) {
    Node *node = (Node *) malloc(sizeof(Node));
    node->c = c;
    node->freq = freq;
    node->left = left;
    node->right = right;
    return node;
}

MinHeap *create_heap(int capacity) {
    MinHeap *heap = (MinHeap *) malloc(sizeof(MinHeap));
    heap->size = 0;
    heap->nodes = (Node **) malloc(capacity * sizeof(Node *));
    return heap;
}

void swap_nodes(Node **a, Node **b) {
    Node *temp = *a;
    *a = *b;
    *b = temp;
}

void heapify(MinHeap *heap, int idx) {
    int smallest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    if (left < heap->size && heap->nodes[left]->freq < heap->nodes[smallest]->freq) {
        smallest = left;
    }
    if (right < heap->size && heap->nodes[right]->freq < heap->nodes[smallest]->freq) {
        smallest = right;
    }
    if (smallest != idx) {
        swap_nodes(&heap->nodes[idx], &heap->nodes[smallest]);
        heapify(heap, smallest);
    }
}

Node *extract_min(MinHeap *heap) {
    Node *node = heap->nodes[0];
    heap->nodes[0] = heap->nodes[heap->size - 1];
    heap->size--;
    heapify(heap, 0);
    return node;
}

void insert_node(MinHeap *heap, Node *node) {
    heap->size++;
    int i = heap->size - 1;
    while (i && node->freq < heap->nodes[(i - 1) / 2]->freq) {
        heap->nodes[i] = heap->nodes[(i - 1) / 2];
        i = (i - 1) / 2;
    }
    heap->nodes[i] = node;
}

void build_heap(MinHeap *heap) {
    int n = heap->size;
    for (int i = (n - 2) / 2; i >= 0; i--) {
        heapify(heap, i);
    }
}

Node *build_huffman_tree(char *text) {
    int freq[MAX_CHARACTERS] = {0};
    int n = strlen(text);
    for (int i = 0; i < n; i++) {
        freq[(int) text[i]]++;
    }
    MinHeap *heap = create_heap(MAX_TREE_NODES);
    for (int i = 0; i < MAX_CHARACTERS; i++) {
        if (freq[i] > 0) {
            insert_node(heap, create_node((char) i, freq[i], NULL, NULL));
        }
    }
    build_heap(heap);
    while (heap->size > 1) {
        Node *left = extract_min(heap);
        Node *right = extract_min(heap);
        Node *parent = create_node('$', left->freq + right->freq, left, right);
        insert_node(heap, parent);
    }
    return extract_min(heap);
}

void generate_codes(Node *root, char *prefix, int idx, HuffmanCode *codes) {
    if (root) {
        if (root->c != '$') {
            codes[root->c].c = root->c;
            codes[root->c].code[idx] = '\0';
            strcpy(codes[root->c].code, prefix);
        }
        prefix[idx] = '0';
        generate_codes(root->left, prefix, idx + 1, codes);
        prefix[idx] = '1';
        generate_codes(root->right, prefix, idx + 1, codes);
    }
}

void encode_text(char *text, HuffmanCode *codes, char *encoded) {
    int n = strlen(text);
    int idx = 0;
    for (int i = 0; i < n; i++) {
        if (isalpha(text[i]) || text[i] == ' ') {
            strcat(encoded, codes[(int) text[i]].code);
        }
    }
}

void decode_text(Node *root, char *encoded) {
    Node *node = root;
    int n = strlen(encoded);
    for (int i = 0; i < n; i++) {
        if (encoded[i] == '0') {
            node = node->left;
        } else {
            node = node->right;
        }
        if (node->left == NULL && node->right == NULL) {
            printf("%c", node->c);
            node = root;
        }
    }
}

int main() {
    char text[MAX_TREE_NODES];
    printf("Enter the text to be encoded: ");
    fgets(text, MAX_TREE_NODES, stdin);
    Node *root = build_huffman_tree(text);
    char prefix[MAX_BIT_LENGTH];
    HuffmanCode codes[MAX_CHARACTERS];
    generate_codes(root, prefix, 0, codes);
    char encoded[MAX_TREE_NODES] = "";
    encode_text(text, codes, encoded);
    printf("Encoded text: %s\n", encoded);
    printf("Decoded text: ");
    decode_text(root, encoded);
    printf("\n");
    return 0;
}

说明：

1. 使用结构体 `Node` 来表示Huffman树中的节点。
2. 使用结构体 `MinHeap` 来表示Huffman树中的最小堆。
3. `build_huffman_tree` 函数用于构建Huffman树。
4. `generate_codes` 函数用于生成Huffman编码。
5. `encode_text` 函数用于编码文本。
6. `decode_text` 函数用于解码文本。
7. `main` 函数用于输入文本、构建Huffman树、生成编码、编码文本、解码文本并输出结果。