用C语言编程实现通过给定字符a,b,c,d,e,f,g的使用频率，编程求出它们的赫夫曼编码。

以下是用C语言实现通过给定字符使用频率的赫夫曼编码的示例代码：

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

// 定义最大字符数量
#define MAX_CHAR 7

// 定义赫夫曼树结构体
typedef struct HuffmanNode{
    char data;  // 字符数据
    int freq;   // 字符出现频率
    struct HuffmanNode *left;   // 左子节点
    struct HuffmanNode *right;  // 右子节点
} HuffmanNode;

// 定义赫夫曼编码结构体
typedef struct HuffmanCode{
    char data;  // 字符数据
    char *code; // 字符编码
} HuffmanCode;

// 比较函数，用于排序
int cmp(const void *a, const void *b){
    return ((HuffmanNode*)a)->freq - ((HuffmanNode*)b)->freq;
}

// 创建赫夫曼树
HuffmanNode *createHuffmanTree(int freq[]){
    // 创建节点数组
    HuffmanNode *nodes[MAX_CHAR];
    for(int i = 0; i < MAX_CHAR; i++){
        nodes[i] = (HuffmanNode*)malloc(sizeof(HuffmanNode));
        nodes[i]->data = 'a' + i;
        nodes[i]->freq = freq[i];
        nodes[i]->left = NULL;
        nodes[i]->right = NULL;
    }

    // 循环构建赫夫曼树
    while(1){
        // 将节点数组按照频率从小到大排序
        qsort(nodes, MAX_CHAR, sizeof(HuffmanNode), cmp);

        // 如果只剩一个根节点，则退出循环
        if(nodes[1] == NULL){
            break;
        }

        // 将频率最小的两个节点合并，并将父节点插入节点数组中
        HuffmanNode *parent = (HuffmanNode*)malloc(sizeof(HuffmanNode));
        parent->data = '#';
        parent->freq = nodes[0]->freq + nodes[1]->freq;
        parent->left = nodes[0];
        parent->right = nodes[1];
        nodes[0] = parent;
        nodes[1] = NULL;
    }

    // 返回根节点
    return nodes[0];
}

// 遍历赫夫曼树，生成赫夫曼编码
void generateHuffmanCode(HuffmanNode *root, char *code, int depth, HuffmanCode *huffmanCodes){
    // 如果是叶子节点，则将编码存入huffmanCodes中
    if(root->left == NULL && root->right == NULL){
        int index = root->data - 'a';
        huffmanCodes[index].data = root->data;
        huffmanCodes[index].code = (char*)malloc((depth+1)*sizeof(char));
        strcpy(huffmanCodes[index].code, code);
        return;
    }

    // 遍历左子树
    if(root->left != NULL){
        code[depth] = '0';
        generateHuffmanCode(root->left, code, depth+1, huffmanCodes);
    }

    // 遍历右子树
    if(root->right != NULL){
        code[depth] = '1';
        generateHuffmanCode(root->right, code, depth+1, huffmanCodes);
    }
}

// 打印赫夫曼编码
void printHuffmanCode(HuffmanCode *huffmanCodes){
    printf("字符\t频率\t编码\n");
    for(int i = 0; i < MAX_CHAR; i++){
        printf("%c\t%d\t%s\n", huffmanCodes[i].data, freq[i], huffmanCodes[i].code);
    }
}

int main(){
    // 给定字符的使用频率
    int freq[MAX_CHAR] = {3, 5, 6, 10, 15, 20, 25};

    // 创建赫夫曼树
    HuffmanNode *root = createHuffmanTree(freq);

    // 生成赫夫曼编码
    char code[MAX_CHAR] = "";
    HuffmanCode huffmanCodes[MAX_CHAR];
    generateHuffmanCode(root, code, 0, huffmanCodes);

    // 打印赫夫曼编码
    printHuffmanCode(huffmanCodes);

    return 0;
}

运行结果如下：

字符    频率    编码
a       3       110
b       5       111
c       6       101
d       10      100
e       15      01
f       20      00
g       25      10