用C语言编写程序，输入结点个数及各结点对应的权值，创建哈夫曼树，生成哈夫曼编码并输出。 输入说明：先输入结点个数，然后依次输入各结点对应的权值。 输出说明：依次输出各结点的哈夫曼编码。（每个结点的哈夫曼编码输出后需换行）

以下是使用C语言编写的程序，实现输入结点个数及各结点对应的权值，创建哈夫曼树，生成哈夫曼编码并输出。

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

#define MAX_NODE 100

typedef struct TreeNode {
    int weight;
    int parent;
    int lchild;
    int rchild;
} TreeNode;

void createHuffmanTree(TreeNode *huffmanTree, int n);
void generateHuffmanCode(TreeNode *huffmanTree, char (*huffmanCode)[MAX_NODE], int n);
void printHuffmanCode(char (*huffmanCode)[MAX_NODE], int n);

int main() {
    int n, i;
    TreeNode huffmanTree[MAX_NODE];
    char huffmanCode[MAX_NODE][MAX_NODE];
    printf("请输入结点个数：");
    scanf("%d", &n);
    printf("请输入各结点对应的权值：\n");
    for (i = 0; i < n; i++) {
        scanf("%d", &huffmanTree[i].weight);
    }
    createHuffmanTree(huffmanTree, n);
    generateHuffmanCode(huffmanTree, huffmanCode, n);
    printHuffmanCode(huffmanCode, n);
    return 0;
}

void createHuffmanTree(TreeNode *huffmanTree, int n) {
    int i, j, k, min1, min2;
    for (i = 0; i < 2 * n - 1; i++) {
        huffmanTree[i].parent = -1;
        huffmanTree[i].lchild = -1;
        huffmanTree[i].rchild = -1;
    }
    for (i = 0; i < n - 1; i++) {
        min1 = min2 = MAX_NODE;
        k = 0;
        for (j = 0; j < n + i; j++) {
            if (huffmanTree[j].parent == -1 && huffmanTree[j].weight < min1) {
                min2 = min1;
                min1 = huffmanTree[j].weight;
                k = j;
            } else if (huffmanTree[j].parent == -1 && huffmanTree[j].weight < min2) {
                min2 = huffmanTree[j].weight;
            }
        }
        huffmanTree[k].parent = n + i;
        huffmanTree[n + i].lchild = k;
        min1 = min2 = MAX_NODE;
        k = 0;
        for (j = 0; j < n + i; j++) {
            if (huffmanTree[j].parent == -1 && huffmanTree[j].weight < min1) {
                min2 = min1;
                min1 = huffmanTree[j].weight;
                k = j;
            } else if (huffmanTree[j].parent == -1 && huffmanTree[j].weight < min2) {
                min2 = huffmanTree[j].weight;
            }
        }
        huffmanTree[k].parent = n + i;
        huffmanTree[n + i].rchild = k;
        huffmanTree[n + i].weight = huffmanTree[n + i].lchild + huffmanTree[n + i].rchild;
    }
}

void generateHuffmanCode(TreeNode *huffmanTree, char (*huffmanCode)[MAX_NODE], int n) {
    int i, j, start, current, parent;
    char temp[MAX_NODE];
    temp[n - 1] = '\0';
    for (i = 0; i < n; i++) {
        start = n - 1;
        current = i;
        parent = huffmanTree[current].parent;
        while (parent != -1) {
            if (huffmanTree[parent].lchild == current) {
                temp[--start] = '0';
            } else {
                temp[--start] = '1';
            }
            current = parent;
            parent = huffmanTree[current].parent;
        }
        for (j = start; j < n; j++) {
            huffmanCode[i][j - start] = temp[j];
        }
    }
}

void printHuffmanCode(char (*huffmanCode)[MAX_NODE], int n) {
    int i, j;
    printf("各结点对应的哈夫曼编码如下：\n");
    for (i = 0; i < n; i++) {
        printf("%d: ", i);
        for (j = 0; huffmanCode[i][j] != '\0'; j++) {
            printf("%c", huffmanCode[i][j]);
        }
        printf("\n");
    }
}

程序流程：

1. 定义哈夫曼树的结点结构体 `TreeNode`，包括权值、父节点、左子节点和右子节点。
2. 定义函数 `createHuffmanTree`，用于创建哈夫曼树。
3. 定义函数 `generateHuffmanCode`，用于生成哈夫曼编码。
4. 定义函数 `printHuffmanCode`，用于输出各结点的哈夫曼编码。
5. 在 `main` 函数中，输入结点个数和各结点对应的权值，然后调用上述三个函数，依次创建哈夫曼树、生成哈夫曼编码和输出哈夫曼编码。

其中，创建哈夫曼树的算法采用贪心思想，每次选择权值最小的两个结点合并，直到只剩下一个根节点。生成哈夫曼编码的算法采用递归思想，从当前结点向上遍历，记录路径上的 0 和 1，直到到达根节点。输出哈夫曼编码时，按照结点的顺序依次输出对应的编码。

注意：上述程序中，定义了常量 `MAX_NODE`，表示哈夫曼树的最大结点数。在实际使用时，应根据需要进行修改。