从键盘任意输入一个字符串，编写算法求其长度c语言

以下是一个用C语言编写的函数 `converse(char[] s)`，用于将字符串逆序： ```c #include <stdio.h> #include <string.h> // 函数声明 void converse(char[] s); int main() { char str[100]; // 从键盘输入字符串 printf("请输入一个字符串: "); scanf("%s", str); // 调用函数将字符串逆序 converse(str); // 输出逆序后的字符串 printf("逆序后的字符串: %s\n", str); return 0; } // 函数定义：将字符串逆序 void converse(char[] s) { int len = strlen(s); int i; char temp; // 交换字符串的首尾字符 for (i = 0; i < len / 2; i++) { temp = s[i]; s[i] = s[len - i - 1]; s[len - i - 1] = temp; } } ``` 在这个程序中： 1. 我们定义了一个 `converse` 函数，它接受一个字符数组作为参数。 2. 在 `main` 函数中，我们首先从键盘读取一个字符串。 3. 然后我们调用 `converse` 函数来逆序这个字符串。 4. 最后，我们输出逆序后的字符串。 5. `converse` 函数内部使用了一个简单的交换算法，将字符串的首尾字符逐对交换，从而实现逆序。 这个程序可以处理任意长度的字符串，只要不超过数组的大小（这里设置为100）。

好的，根据您的要求，我为您编写了以下代码，可以实现从键盘任意输入一个由英文字母带空格构成的文本字符串，利用 Huffman 编码和解码算法进行编码和解码，并将编码结果输出到屏幕上。 Huffman编码的过程是：首先统计每个字符在输入字符串中出现的频率，然后根据字符频率构建哈夫曼树，接着对哈夫曼树进行遍历，对于每个字符，输出其对应的二进制编码。解码过程是根据哈夫曼树以及编码结果进行逆向遍历，得到原始字符串。 代码如下： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 哈夫曼树节点结构体 typedef struct HuffmanNode { char data; // 节点保存的字符 int freq; // 字符出现的频率 struct HuffmanNode *left, *right; // 左右子节点 } HuffmanNode; // 哈夫曼编码结构体 typedef struct HuffmanCode { char data; // 字符 char *code; // 对应的哈夫曼编码 } HuffmanCode; // 统计字符串中每个字符出现的频率 int *countFreq(char *str) { int *freq = (int *)calloc(256, sizeof(int)); // 初始化为0 char *p = str; while (*p != '\0') { freq[*p++]++; } return freq; } // 创建哈夫曼树 HuffmanNode *createHuffmanTree(char *str) { // 统计字符串中每个字符出现的频率 int *freq = countFreq(str); // 创建哈夫曼节点数组 HuffmanNode **nodes = (HuffmanNode **)malloc(sizeof(HuffmanNode *) * 256); int count = 0; for (int i = 0; i < 256; i++) { if (freq[i] > 0) { HuffmanNode *node = (HuffmanNode *)malloc(sizeof(HuffmanNode)); node->data = (char)i; node->freq = freq[i]; node->left = node->right = NULL; nodes[count++] = node; } } free(freq); // 释放频率统计数组 // 构建哈夫曼树 while (count > 1) { // 找到频率最小的两个节点 int min1 = 0, min2 = 1; if (nodes[min1]->freq > nodes[min2]->freq) { int temp = min1; min1 = min2; min2 = temp; } for (int i = 2; i < count; i++) { if (nodes[i]->freq < nodes[min1]->freq) { min2 = min1; min1 = i; } else if (nodes[i]->freq < nodes[min2]->freq) { min2 = i; } } // 创建新节点 HuffmanNode *newNode = (HuffmanNode *)malloc(sizeof(HuffmanNode)); newNode->data = '\0'; newNode->freq = nodes[min1]->freq + nodes[min2]->freq; newNode->left = nodes[min1]; newNode->right = nodes[min2]; // 将新节点加入节点数组中 nodes[min1] = newNode; nodes[min2] = nodes[count - 1]; count--; } // 返回哈夫曼树的根节点 return nodes[0]; } // 释放哈夫曼树的内存 void freeHuffmanTree(HuffmanNode *root) { if (root != NULL) { freeHuffmanTree(root->left); freeHuffmanTree(root->right); free(root); } } // 递归遍历哈夫曼树，生成哈夫曼编码 void generateHuffmanCode(HuffmanNode *root, char *code, int depth, HuffmanCode *huffmanCodes) { if (root->left == NULL && root->right == NULL) { // 生成哈夫曼编码 code[depth] = '\0'; int i; for (i = 0; huffmanCodes[i].data != '\0'; i++) { if (huffmanCodes[i].data == root->data) { huffmanCodes[i].code = (char *)malloc(sizeof(char) * (depth + 1)); strcpy(huffmanCodes[i].code, code); break; } } if (huffmanCodes[i].data == '\0') { huffmanCodes[i].data = root->data; huffmanCodes[i].code = (char *)malloc(sizeof(char) * (depth + 1)); strcpy(huffmanCodes[i].code, code); huffmanCodes[i + 1].data = '\0'; } return; } // 递归遍历左右子树 code[depth] = '0'; generateHuffmanCode(root->left, code, depth + 1, huffmanCodes); code[depth] = '1'; generateHuffmanCode(root->right, code, depth + 1, huffmanCodes); } // 利用哈夫曼编码将字符串进行编码 char *encodeString(char *str, HuffmanCode *huffmanCodes) { // 计算编码后字符串的长度 int len = 0; char *p = str; while (*p != '\0') { for (int i = 0; huffmanCodes[i].data != '\0'; i++) { if (*p == huffmanCodes[i].data) { len += strlen(huffmanCodes[i].code); break; } } p++; } // 分配空间并进行编码 char *codeStr = (char *)malloc(sizeof(char) * (len + 1)); char *q = codeStr; p = str; while (*p != '\0') { for (int i = 0; huffmanCodes[i].data != '\0'; i++) { if (*p == huffmanCodes[i].data) { strcat(q, huffmanCodes[i].code); q += strlen(huffmanCodes[i].code); break; } } p++; } *q = '\0'; return codeStr; } // 利用哈夫曼编码将0-1编码流进行解码 char *decodeString(char *codeStr, HuffmanNode *root) { int len = strlen(codeStr); char *str = (char *)malloc(sizeof(char) * (len + 1)); HuffmanNode *p = root; char *q = str; for (int i = 0; i < len; i++) { if (codeStr[i] == '0') { p = p->left; } else { p = p->right; } if (p->left == NULL && p->right == NULL) { *q++ = p->data; p = root; } } *q = '\0'; return str; } int main() { char str[1000]; printf("请输入字符串："); gets(str); // 创建哈夫曼树 HuffmanNode *root = createHuffmanTree(str); // 生成哈夫曼编码 char code[256]; HuffmanCode huffmanCodes[256]; memset(huffmanCodes, 0, sizeof(huffmanCodes)); generateHuffmanCode(root, code, 0, huffmanCodes); // 输出哈夫曼编码表 printf("字符\t频率\t编码\n"); for (int i = 0; huffmanCodes[i].data != '\0'; i++) { printf("%c\t%d\t%s\n", huffmanCodes[i].data, countFreq(str)[huffmanCodes[i].data], huffmanCodes[i].code); } // 编码 char *codeStr = encodeString(str, huffmanCodes); printf("编码结果：%s\n", codeStr); // 解码 char *decodeStr = decodeString(codeStr, root); printf("解码结果：%s\n", decodeStr); // 释放内存 freeHuffmanTree(root); free(codeStr); free(decodeStr); for (int i = 0; huffmanCodes[i].data != '\0'; i++) { free(huffmanCodes[i].code); } return 0; } ``` > 注意：为了简化代码，没有对输入的字符串进行长度限制。实际应用中需要根据具体情况进行限制。