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

好的，我可以为您解答关于使用C语言编写Huffman编码的问题。首先，需要实现以下几个步骤：

1. 读取文本字符串并统计字符出现频率
2. 构建Huffman树
3. 生成Huffman编码表
4. 对文本字符串进行Huffman编码
5. 将Huffman编码结果输出到屏幕
6. 对Huffman编码进行解码，得到原始文本字符串

下面是具体实现：

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

#define MAX_TREE_HT 100 

struct MinHeapNode { 
    char data; 
    unsigned freq; 
    struct MinHeapNode *left, *right; 
}; 
  
struct MinHeap { 
    unsigned size; 
    unsigned capacity; 
    struct MinHeapNode **array; 
}; 

struct MinHeapNode* newNode(char data, unsigned freq) { 
    struct MinHeapNode* temp = (struct MinHeapNode*)malloc(sizeof(struct MinHeapNode)); 
    temp->left = temp->right = NULL; 
    temp->data = data; 
    temp->freq = freq; 
    return temp; 
} 

struct MinHeap* createMinHeap(unsigned capacity) { 
    struct MinHeap* minHeap = (struct MinHeap*)malloc(sizeof(struct MinHeap)); 
    minHeap->size = 0; 
    minHeap->capacity = capacity; 
    minHeap->array = (struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*)); 
    return minHeap; 
} 

void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b) { 
    struct MinHeapNode* t = *a; 
    *a = *b; 
    *b = t; 
} 

void minHeapify(struct MinHeap* minHeap, int idx) { 
    int smallest = idx; 
    int left = 2 * idx + 1; 
    int right = 2 * idx + 2; 
    if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq) 
        smallest = left; 
    if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq) 
        smallest = right; 
    if (smallest != idx) { 
        swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]); 
        minHeapify(minHeap, smallest); 
    } 
} 

int isSizeOne(struct MinHeap* minHeap) { 
    return (minHeap->size == 1); 
} 

struct MinHeapNode* extractMin(struct MinHeap* minHeap) { 
    struct MinHeapNode* temp = minHeap->array[0]; 
    minHeap->array[0] = minHeap->array[minHeap->size - 1]; 
    --minHeap->size; 
    minHeapify(minHeap, 0); 
    return temp; 
} 

void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode) { 
    ++minHeap->size; 
    int i = minHeap->size - 1; 
    while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) { 
        minHeap->array[i] = minHeap->array[(i - 1) / 2]; 
        i = (i - 1) / 2; 
    } 
    minHeap->array[i] = minHeapNode; 
} 

void buildMinHeap(struct MinHeap* minHeap) { 
    int n = minHeap->size - 1; 
    int i; 
    for (i = (n - 1) / 2; i >= 0; --i) 
        minHeapify(minHeap, i); 
} 

void printArr(int arr[], int n) { 
    int i; 
    for (i = 0; i < n; ++i) 
        printf("%d", arr[i]); 
    printf("\n"); 
} 

int isLeaf(struct MinHeapNode* root) { 
    return !(root->left) && !(root->right); 
} 

struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size) { 
    struct MinHeap* minHeap = createMinHeap(size); 
    for (int i = 0; i < size; ++i) 
        minHeap->array[i] = newNode(data[i], freq[i]); 
    minHeap->size = size; 
    buildMinHeap(minHeap); 
    return minHeap; 
} 

struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size) { 
    struct MinHeapNode *left, *right, *top; 
    struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size); 
    while (!isSizeOne(minHeap)) { 
        left = extractMin(minHeap); 
        right = extractMin(minHeap); 
        top = newNode('$', left->freq + right->freq); 
        top->left = left; 
        top->right = right; 
        insertMinHeap(minHeap, top); 
    } 
    return extractMin(minHeap); 
} 

void printCodes(struct MinHeapNode* root, int arr[], int top) { 
    if (root->left) { 
        arr[top] = 0; 
        printCodes(root->left, arr, top + 1); 
    } 
    if (root->right) { 
        arr[top] = 1; 
        printCodes(root->right, arr, top + 1); 
    } 
    if (isLeaf(root)) { 
        printf("%c: ", root->data); 
        printArr(arr, top); 
    } 
} 

void HuffmanCodes(char data[], int freq[], int size) { 
    struct MinHeapNode* root = buildHuffmanTree(data, freq, size); 
    int arr[MAX_TREE_HT], top = 0; 
    printCodes(root, arr, top); 
} 

void encodeHuffman(char *str, char codes[][MAX_TREE_HT]) {
    int len = strlen(str);
    int i, j;
    for (i = 0; i < len; i++) {
        for (j = 0; j < MAX_TREE_HT; j++) {
            codes[(int)str[i]][j] = '\0';
        }
    }

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

    char data[256];
    int pos = 0;
    for (i = 0; i < 256; i++) {
        if (freq[i] != 0) {
            data[pos++] = (char)i;
        }
    }

    HuffmanCodes(data, freq, pos);

    struct MinHeapNode *root = buildHuffmanTree(data, freq, pos);
    int arr[MAX_TREE_HT], top = 0;
    printCodes(root, arr, top);

    for (i = 0; i < pos; i++) {
        int k = 0;
        for (j = 0; j < MAX_TREE_HT; j++) {
            if (codes[(int)data[i]][j] != '\0') {
                k++;
            }
        }
        if (k == 0) {
            codes[(int)data[i]][0] = '0';
            k++;
        }
    }

    for (i = 0; i < len; i++) {
        for (j = 0; j < MAX_TREE_HT; j++) {
            if (codes[(int)str[i]][j] != '\0') {
                printf("%c", codes[(int)str[i]][j]);
            }
        }
    }
}

void decodeHuffman(char *str, struct MinHeapNode *root) {
    struct MinHeapNode *p = root;
    int len = strlen(str);
    int i;
    for (i = 0; i < len; i++) {
        if (str[i] == '0') {
            p = p->left;
        } else {
            p = p->right;
        }
        if (isLeaf(p)) {
            printf("%c", p->data);
            p = root;
        }
    }
}

int main() {
    char str[100];
    char codes[256][MAX_TREE_HT] = {{0}};

    printf("请输入待压缩的字符串：");
    fgets(str, sizeof(str), stdin);
    str[strlen(str) - 1] = '\0';

    printf("Huffman编码结果为：");
    encodeHuffman(str, codes);
    printf("\n");

    printf("Huffman解码结果为：");
    decodeHuffman(codes, buildHuffmanTree);
    printf("\n");

    return 0;
}

以上代码实现了对一个由英文字母带空格构成的文本字符串进行Huffman编码，并且能够对Huffman编码结果进行解码，得到原始的文本字符串。其中，我们使用了Huffman树来生成Huffman编码表，再利用Huffman编码表对文本字符串进行编码。同时，我们也实现了Huffman解码，将编码结果转换为原始文本字符串。