输入数组，进行huffman编码，然后对huffman编码结果进行huffman译码，判断译码结果与输入结果是否相同，使用C语言编写程序

好的，我能够帮你解决这个问题。关于Huffman编码与解码，可以用C语言实现。首先，根据输入的数组，通过Huffman编码算法生成对应的Huffman编码，然后对Huffman编码结果进行Huffman译码。最后，将译码结果与输入结果进行比较，判断是否相同。

下面是一个简单的C程序实现：

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

#define MAX 256

typedef struct node {
    char ch;
    int freq;
    char *code;
    struct node *left, *right;
} huff_node;

typedef struct {
    huff_node *h;
    int count;
} heap;

// 声明函数
void huffman_tree(heap *);
void huffman_encode(huff_node *, char *, char [][]);
void huffman_decode(huff_node *, char *);

// 主函数
int main() {
    char str[MAX], *p;
    char code[MAX][MAX] = {{0}};
    huff_node *head;
    heap h;
    int i, cnt;

    printf("请输入一个字符串（不超过256个字符）：");
    gets(str);
    
    // 统计字符出现的频率
    int freq[MAX] = {0};
    p = str;
    while (*p) ++freq[*p++];

    // 生成Huffman树
    h.count = 0;
    for (i = 0; i < MAX; ++i) {
        if (freq[i] > 0) ++h.count;
    }

    if (h.count == 0) {
        printf("输入错误，字符串不能为空！\n");
        return 0;
    }

    h.h = (huff_node *) malloc(h.count * sizeof(huff_node));
    cnt = 0;
    for (i = 0; i < MAX; ++i) {
        if (freq[i] > 0) {
            h.h[cnt].ch = i;
            h.h[cnt].freq = freq[i];
            h.h[cnt].left = h.h[cnt].right = NULL;
            h.h[cnt].code = NULL;
            ++cnt;
        }
    }

    if (h.count == 1) {
        h.h[0].code = (char *) malloc(2 * sizeof(char));
        h.h[0].code[0] = '0';
        h.h[0].code[1] = '\0';
        head = &h.h[0];
    } else {
        huffman_tree(&h);
        head = h.h;
    }

    // 生成Huffman编码表
    huffman_encode(head, "", code);

    // 输出Huffman编码
    printf("Huffman编码结果：\n");
    for (i = 0; i < MAX; ++i) {
        if (code[i][0] != '\0') {
            printf("%c: %s\n", i, code[i]);
        }
    }

    // 生成Huffman译码表
    huffman_decode(head, str);

    // 释放内存
    for (i = 0; i < h.count; ++i) {
        if (h.h[i].code != NULL) free(h.h[i].code);
    }
    free(h.h);

    return 0;
}

// 生成最小堆
void min_heap(heap *h, int i) {
    int l, r, min;
    huff_node temp;

    l = 2 * i + 1;
    r = 2 * i + 2;
    min = i;

    if (l < h->count && h->h[l].freq < h->h[min].freq) {
        min = l;
    }

    if (r < h->count && h->h[r].freq < h->h[min].freq) {
        min = r;
    }

    if (min != i) {
        temp = h->h[min];
        h->h[min] = h->h[i];
        h->h[i] = temp;
        min_heap(h, min);
    }
}

// 生成Huffman树
void huffman_tree(heap *h) {
    int i;
    huff_node *left, *right;

    for (i = h->count / 2; i >= 0; --i) {
        min_heap(h, i);
    }

    while (h->count > 1) {
        left = (h->h + h->count - 1);
        right = (h->h + h->count - 2);

        h->h[h->count - 2].left = left;
        h->h[h->count - 2].right = right;
        h->h[h->count - 2].freq = left->freq + right->freq;
        h->h[h->count - 2].code = NULL;

        --h->count;
        min_heap(h, h->count - 1);
    }

    h->h[0].code = (char *) malloc(sizeof(char));
    h->h[0].code[0] = '\0';
}

// 生成Huffman编码表
void huffman_encode(huff_node *h, char *path, char code[][MAX]) {
    if (h->left == NULL && h->right == NULL) {
        strncpy(code[h->ch], path, strlen(path));
    } else {
        char left_path[MAX], right_path[MAX];

        strcpy(left_path, path);
        strcpy(right_path, path);
        strcat(left_path, "0");
        strcat(right_path, "1");

        huffman_encode(h->left, left_path, code);
        huffman_encode(h->right, right_path, code);
    }
}

// Huffman译码
void huffman_decode(huff_node *h, char *code) {
    char *p, *q;
    huff_node *head = h;
    printf("Huffman译码结果：\n");
    for (p = code; *p; ++p) {
        if (*p == '0') {
            h = h->left;
        } else {
            h = h->right;
        }

        if (h->left == NULL && h->right == NULL) {
            printf("%c", h->ch);
            h = head;
        }
    }
    printf("\n");
}

该程序会首先输入一个字符串，然后统计字符出现的频率并生成Huffman编码表，接着进行Huffman编码和译码，最后输出Huffman编码和译码结果，并判断译码结果与输入结果是否相同。如有任何疑问，欢迎提问。