C语言中一个字符对应一个ascii码;占一个1个字节8个二进制位;存到内存中也是用ascii的十进制的二进制表示...

/**
只读变量和常量 const 只读
const int a;
int const a;//同上面的代码行是等价的,都表示一个常整形数。

int *const a;//const具有"左结合"性,即const修饰*,那么,不难理解,该句表示一个指向整数的常指针,a指向的整数可以修改,但指针a不能修改。
const int *a;//与下面的这一行等价,根据"左结合"性,const修饰的是(*a),也即是一个整数,所以,这两句表示指针指向一个常整数。
int const *a;
int const *a const;//根据"左结合"性质,第一个const修饰(*),第二个const修饰(a),因此,这句话表示一个指向常整数的常指针。
**/
#include <stdio.h>
#define PI 3.145926145926
int main(void){
	const int a = 10;//不能修改的常量 常数,不变的
	int const b = 2.3E2;//不能修改等同上面的 2*10的2次方 E以10为底数的幂
	//可以用指针修改变量
	
	//int *p = &a;//指针可以改
	//*p = 55;
	//printf("%07.3f\n",PI); //值保留3位小数;包括小数点共7位;不够前补0
	
	//int c = sizeof(float); // int float long 占4个字节 32位
	char c = 'a'; //一个字符或者字母占用1个字节8个二进制位 最小的是1-255 
	//c = sizeof(c);
	printf("%d",c);//97输出的是ascii 01100010 存的是a 也就是说 字符也是用二进制存取的
	return 0;
}

  

转载于:https://www.cnblogs.com/wanglijun/p/8467271.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,这是一个非常有趣的问题,让我们来逐步实现它。 ## 统计文件字符出现的频次 首先,我们需要读取文件并统计每个字符出现的频次。这可以通过使用一个计数数组来实现,其数组的索引是字符ASCII 码,而数组的值是该字符出现的次数。 ```c #include <stdio.h> #include <stdlib.h> #define ASCII_SIZE 128 int *count_frequency(FILE *fp) { int *count = calloc(ASCII_SIZE, sizeof(int)); int c; while ((c = fgetc(fp)) != EOF) { count[c]++; } return count; } ``` 在上面的代码,我们使用 `calloc` 函数来分配大小为 `ASCII_SIZE` 的数组,并将其初始化为 0。然后,我们使用 `fgetc` 函数从文件逐个读取字符,并使用 `count` 数组记录每个字符出现的次数。 ## 设计哈夫曼编码 接下来,我们需要设计一个哈夫曼编码,将字符映射到二进制编码。为此,我们可以使用一个哈夫曼树,其叶子节点代表每个字符,并且字符出现的频率越高,该节点离根节点越近。 首先,我们需要定义哈夫曼树节点的结构。 ```c typedef struct node { char c; int freq; struct node *left; struct node *right; } node_t; ``` 在上面的代码,`c` 表示节点代表的字符,`freq` 表示字符出现的频率,`left` 和 `right` 分别表示该节点的左右子节点。 然后,我们需要实现一个函数来创建一个新的哈夫曼树节点。 ```c node_t *new_node(char c, int freq) { node_t *node = malloc(sizeof(node_t)); node->c = c; node->freq = freq; node->left = NULL; node->right = NULL; return node; } ``` 在上面的代码,我们使用 `malloc` 函数分配一个新的节点,并将其初始化为指定的字符和频率,左右子节点设置为 `NULL`。 接下来,我们需要实现一个函数来合并两个哈夫曼树节点,并返回它们的父节点。 ```c node_t *merge_nodes(node_t *a, node_t *b) { node_t *node = new_node('\0', a->freq + b->freq); node->left = a; node->right = b; return node; } ``` 在上面的代码,我们使用 `new_node` 函数创建一个新的节点,并将其字符设置为 `'\0'`,频率设置为两个节点的频率之和,左右子节点设置为传递给函数的两个节点。 接下来,我们需要实现一个函数来构建哈夫曼树。我们将使用一个优先队列来存储节点,并按照频率从小到大的顺序排序。我们将使用 `merge_nodes` 函数来合并两个最小频率的节点,直到只剩下一个节点为止,这个节点就是哈夫曼树的根节点。 ```c #include <stdbool.h> #include <string.h> typedef struct queue { node_t **nodes; int size; int capacity; } queue_t; queue_t *new_queue(int capacity) { queue_t *q = malloc(sizeof(queue_t)); q->nodes = calloc(capacity, sizeof(node_t *)); q->size = 0; q->capacity = capacity; return q; } void enqueue(queue_t *q, node_t *node) { int i = q->size++; while (i > 0 && node->freq < q->nodes[(i - 1) / 2]->freq) { q->nodes[i] = q->nodes[(i - 1) / 2]; i = (i - 1) / 2; } q->nodes[i] = node; } node_t *dequeue(queue_t *q) { node_t *node = q->nodes[0]; q->nodes[0] = q->nodes[--q->size]; int i = 0; while (2 * i + 1 < q->size) { int j = 2 * i + 1; if (j + 1 < q->size && q->nodes[j + 1]->freq < q->nodes[j]->freq) { j++; } if (q->nodes[j]->freq < q->nodes[i]->freq) { node_t *temp = q->nodes[i]; q->nodes[i] = q->nodes[j]; q->nodes[j] = temp; i = j; } else { break; } } return node; } void destroy_queue(queue_t *q) { free(q->nodes); free(q); } node_t *build_huffman_tree(int *freq) { queue_t *q = new_queue(ASCII_SIZE); for (int i = 0; i < ASCII_SIZE; i++) { if (freq[i] > 0) { enqueue(q, new_node(i, freq[i])); } } while (q->size > 1) { node_t *a = dequeue(q); node_t *b = dequeue(q); enqueue(q, merge_nodes(a, b)); } node_t *root = dequeue(q); destroy_queue(q); return root; } ``` 在上面的代码,我们首先定义一个 `queue_t` 结构,其 `nodes` 是一个指向节点指针的数组,`size` 表示队列的节点数,`capacity` 表示数组的大小。我们使用 `new_queue` 函数创建一个新的队列,并使用 `enqueue` 函数将节点插入队列。我们使用 `dequeue` 函数从队列删除最小频率的节点,并使用 `destroy_queue` 函数销毁队列。 `build_huffman_tree` 函数接受一个指向频率数组的指针,并返回一个指向哈夫曼树根节点的指针。我们首先使用 `new_queue` 函数创建一个新的队列,并使用 `enqueue` 函数将所有频率大于 0 的节点插入队列。然后,我们使用 `dequeue` 函数从队列删除两个最小频率的节点,并使用 `merge_nodes` 函数将它们合并为一个父节点。我们将新的父节点插入队列,直到队列只剩下一个节点为止,这个节点就是哈夫曼树的根节点。 现在,我们可以使用 `build_huffman_tree` 函数来构建哈夫曼树。 ```c node_t *root = build_huffman_tree(count_frequency(fp)); ``` ## 实现文件的压缩 一旦我们有了哈夫曼编码,我们就可以使用它来压缩文件。对于每个字符,我们可以使用哈夫曼编码将其映射到二进制编码,并将此编码写入输出文件。为了使解码更容易,我们需要在输出文件写入哈夫曼树的结构,这样我们就可以在解码时使用它来将二进制编码转换回字符。 首先,我们需要定义一个结构来存储哈夫曼编码。我们将使用一个位向量来存储二进制编码,并跟踪该编码的位数。 ```c #include <stdbool.h> typedef struct code { bool *bits; int size; } code_t; code_t *new_code(int size) { code_t *code = malloc(sizeof(code_t)); code->bits = calloc(size, sizeof(bool)); code->size = size; return code; } void destroy_code(code_t *code) { free(code->bits); free(code); } ``` 在上面的代码,我们定义了一个 `code_t` 结构,其 `bits` 是一个指向布尔值数组的指针,表示二进制编码,`size` 表示位数。我们使用 `new_code` 函数创建一个新的编码,并使用 `destroy_code` 函数销毁它。 接下来,我们需要实现一个函数来生成哈夫曼编码。我们将使用递归的方式遍历哈夫曼树,并将路径上的每个节点的编码附加到位向量。 ```c void build_code(node_t *node, code_t *prefix, code_t **table) { if (node->left == NULL && node->right == NULL) { table[node->c] = prefix; } else { code_t *left_prefix = new_code(prefix->size + 1); memcpy(left_prefix->bits, prefix->bits, prefix->size * sizeof(bool)); left_prefix->bits[left_prefix->size - 1] = false; build_code(node->left, left_prefix, table); destroy_code(left_prefix); code_t *right_prefix = new_code(prefix->size + 1); memcpy(right_prefix->bits, prefix->bits, prefix->size * sizeof(bool)); right_prefix->bits[right_prefix->size - 1] = true; build_code(node->right, right_prefix, table); destroy_code(right_prefix); } } ``` 在上面的代码,我们使用 `prefix` 位向量来跟踪路径上的节点。如果我们到达一个叶子节点,我们将该节点的编码存储在 `table` 数组。否则,我们使用递归的方式遍历子树,并在路径上添加每个节点的编码。 现在,我们可以使用 `build_code` 函数来生成哈夫曼编码表。 ```c code_t **table = calloc(ASCII_SIZE, sizeof(code_t *)); build_code(root, new_code(0), table); ``` 现在,我们可以开始将输入文件压缩为输出文件。我们首先需要写入哈夫曼树的结构,以便在解压缩时使用它来将二进制编码转换回字符。我们将使用前序遍历的方式遍历哈夫曼树,并使用一个特殊的字符表示叶子节点,后跟该节点表示字符。 ```c void write_tree(node_t *node, FILE *fp) { if (node->left == NULL && node->right == NULL) { fputc('\0', fp); fputc(node->c, fp); } else { fputc('\1', fp); write_tree(node->left, fp); write_tree(node->right, fp); } } void compress(FILE *in_fp, FILE *out_fp, code_t **table) { write_tree(root, out_fp); int buffer = 0; int length = 0; int c; while ((c = fgetc(in_fp)) != EOF) { code_t *code = table[c]; for (int i = 0; i < code->size; i++) { buffer = (buffer << 1) | code->bits[i]; length++; if (length == 8) { fputc(buffer, out_fp); buffer = 0; length = 0; } } } if (length > 0) { buffer <<= 8 - length; fputc(buffer, out_fp); } } ``` 在上面的代码,我们使用 `write_tree` 函数写入哈夫曼树的结构。对于每个叶子节点,我们将字符写入输出文件。对于每个非叶子节点,我们将一个特殊的字符写入输出文件,并使用递归的方式遍历子树。 接下来,我们使用 `compress` 函数来压缩输入文件。我们使用 `table` 数组将每个字符映射到哈夫曼编码,并在输出文件写入相应的二进制编码。我们将使用 `buffer` 变量来存储当前编码的位,使用 `length` 变量来跟踪编码的位数。一旦 `buffer` 有 8 位,我们就将它写入输出文件,并重置 `buffer` 和 `length` 变量。如果输入文件的长度不是 8 的倍数,我们需要将最后几个位填充为 0。 现在,我们可以使用以下代码将输入文件压缩为输出文件。 ```c FILE *in_fp = fopen("input.txt", "rb"); FILE *out_fp = fopen("output.bin", "wb"); compress(in_fp, out_fp, table); fclose(in_fp); fclose(out_fp); ``` ## 实现文件的解压缩 现在,我们已经成功地将输入文件压缩为输出文件,并将哈夫曼树的结构写入输出文件。在解压缩时,我们需要先从输出文件读取哈夫曼树的结构,然后使用它将二进制编码转换回字符。 首先,我们需要实现一个函数来从输出文件读取哈夫曼树的结构,并返回根节点的指针。 ```c node_t *read_tree(FILE *fp) { int c = fgetc(fp); if (c == '\0') { return new_node(fgetc(fp), 0); } else { node_t *left = read_tree(fp); node_t *right = read_tree(fp); return merge_nodes(left, right); } } ``` 在上面的代码,我们使用 `fgetc` 函数从输出文件读取一个字符。如果该字符是特殊字符表示叶子节点,我们将从文件读取字符,并使用 `new_node` 函数创建一个新的节点。否则,我们使用递归的方式读取子树,并使用 `merge_nodes` 函数将它们合并为一个父节点。 现在,我们可以使用 `read_tree` 函数从输出文件读取哈夫曼树的结构。 ```c FILE *in_fp = fopen("output.bin", "rb"); node_t *root = read_tree(in_fp); ``` 接下来,我们需要实现一个函数来解压缩输出文件。我们将使用哈夫曼树将二进制编码转换回字符,并将字符写入输入文件。 ```c void decompress(FILE *in_fp, FILE *out_fp, node_t *root) { node_t *node = root; int c; while ((c = fgetc(in_fp)) != EOF) { for (int i = 7; i >= 0; i--) { bool bit = (c >> i) & 1; if (bit) { node = node->right; } else { node = node->left; } if (node->left == NULL && node->right == NULL) { fputc(node->c, out_fp); node = root; } } } } ``` 在上面的代码,我们使用 `root` 变量来跟踪当前节点。对于每个输入字节,我们将其拆分为 8 个位,并使用哈夫曼树将每个位转换回字符。一旦我们到达一个叶子节点,我们将该节点的字符写入输入文件,并将 `node` 变量重置为根节点。 现在,我们可以使用以下代码将输出文件解压缩为输入文件。 ```c FILE *in_fp = fopen("output.bin", "rb"); FILE *out_fp = fopen("input_decompressed.txt", "wb"); decompress(in_fp, out_fp, root); fclose(in_fp); fclose(out_fp); ``` 好了,我们已经成功地实现了一个基于哈夫曼算法的压缩软件!

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值