我正在尝试编写用于编码和解码目的的代码。一旦我们有了字典，形成的字典就存储在一个结构数组中。其结构如下
typedef struct Tuple {
char a;
char* cod;
} result;
原始字符串是字符数组
char str[100];
现在我们需要一种方法来比较原始数组中的字符和形成的字典。 形成的字典是这样的
a ---0
b ---1
c ---01
示例：原始字符串为aabcab，然后编码应为0010101
将字符串与字典数据进行比较的代码如下，但是当代码执行时，结果如下：[警告]传递'strcmp'的参数2使得指针来自整数而没有强制转换[默认启用] 。
帮助将不胜感激。
for(i=0; i<strlen(str);i++)//read the original string;
{
j=0;
while(j<number_of_elements_in_dictionary)// for above example=3
{
if (strcmp(str[i],values[j]->a)==0) //compare original string character with the //dictionary
{
printf("%s", values[j]->cod);//print corresponding code from //dictionary
j++; //check with the next value of the dictionary
}
}
}
printf("last=%s", str_en);//To print the dictionary data corresponding to //the original string data
#include<string.h>
#include<stdio.h>
#include<limits.h>
#include<stdlib.h>
typedef struct node
{
char ch;
int freq;
struct node *left;
struct node *right;
}node;
typedef struct Tuple {
char a;
char* cod;
}result;
/*Declaring heap globally so that we do not need to pass it as an argument every time*/
/* Heap implemented here is Min Heap */
node * heap[1000000];
result * values[200];
int heapSize;
char * str;
char str_en[100];
// str_en[0] = '\0';
/*Initialize Heap*/
void Init()
{
heapSize = 0;
heap[0] = (node *)malloc(sizeof(node));
heap[0]->freq = -INT_MAX;
}
/*Insert an element into the heap */
void Insert(node * element)
{
heapSize++;
heap[heapSize] = element; /*Insert in the last place*/
/*Adjust its position*/
int now = heapSize;
while(heap[now/2] -> freq >= element -> freq)
{
heap[now] = heap[now/2];
now /= 2;
}
heap[now] = element;
}
node * DeleteMin()
{
/* heap[1] is #ifndef
#elif
#endifthe minimum element. So we remove heap[1]. Size of the heap is decreased.
Now heap[1] has to be filled. We put the last element in its place and see if it fits.
If it does not fit, take minimum element among both its children and replaces parent with it.
Again See if the last element fits in that place.*/
node * minElement,*lastElement;
int child,now;
minElement = heap[1];
lastElement = heap[heapSize--];
/* now refers to the index at which we are now */
for(now = 1; now*2 <= heapSize ;now = child)
{
/* child is the index of the element which is minimum among both the children */
/* Indexes of children are i*2 and i*2 + 1*/
child = now*2;
/*child!=heapSize beacuse heap[heapSize+1] does not exist, which means it has only one
child */
if(child != heapSize && heap[child+1]->freq < heap[child] -> freq )
{
child++;
}
/* To check if the last element fits ot not it suffices to check if the last element
is less than the minimum element among both the children*/
if(lastElement -> freq > heap[child] -> freq)
{
heap[now] = heap[child];
}
else /* It fits there */
{
break;
}
}
heap[now] = lastElement;
return minElement;
}
void encode(result *value, int s)
{
int pos,i,j;
pos=1;
values[pos]=value;//Im here
values[pos]->a =value->a;
values[pos]->cod=value->cod;
printf("RESULT= %c and %s", values[pos]->a, values[pos]->cod);
pos++;
/*the problem exists here while executing the following for-loop, the code doesn't execute due to this for loop*/
for(i=0; i<strlen(str);i++){
j=0;
while(j<4)
{
if(str[i]==values[j]->a)
{
printf("%s", values[j]->cod);
j++;
}
} }
printf("last=%s", str_en);
}
void print(node *temp,char *code, int s)//, char *buf)
{
int i,pos=1,j;
if(temp->left==NULL && temp->right==NULL)
{
printf("\n\nchar %c code %s\n",temp->ch,code);
result * value = (result *) malloc(sizeof(result));
value->a=temp->ch;
value->cod= code;
encode(value,s);
return;
}
int length = strlen(code);
char leftcode[512],rightcode[512];
strcpy(leftcode,code);
strcpy(rightcode,code);
leftcode[length] = '0';
leftcode[length+1] = '\0';
rightcode[length] = '1';
rightcode[length+1] = '\0';
print(temp->right,rightcode,s);
print(temp->left,leftcode,s);
}
/* Given the list of characters along with their frequencies, our goal is to predict the encoding of the
characters such that total length of message when encoded becomes minimum */
int main()
{
char buf[250];
char character[26];
int i = 0,j=0,count[26]={0};
char c = 97;
Init();
int distinct_char=0 ;
char ch;
int freq;
int iter;
printf("enter the string");
scanf("%s", str);
printf("string=%s",str);
for (i=0; i<strlen(str);i++)
{
for(j=0;j<26;j++)
{
if (tolower(str[i]) == (c+j))
{
count[j]++;
}
}
}
for(j=0;j<26;j++)
{
if(count[j]>0)
{
printf("\n%c -> %d",97+j,count[j]);
distinct_char++;
character[j] = 97+j;
}
}
printf("\n number of distinct_characters=%d\n", distinct_char);
if(distinct_char==1)
{
printf("char %c code 0\n",c);
return 0;
}
for(j=0;j<distinct_char;j++)
{
printf("\ncharacter= %c and the frequency=%d", character[j],count[j]);
node * temp = (node *) malloc(sizeof(node));
temp -> ch = character[j];
temp -> freq = count[j];
temp -> left = temp -> right = NULL;
Insert(temp);
}
for(i=0;i<distinct_char-1 ;i++)
{
node * left = DeleteMin();
node * right = DeleteMin();
node * temp = (node *) malloc(sizeof(node));
temp -> ch = 0;
temp -> left = left;
temp -> right = right;
temp -> freq = left->freq + right -> freq;
Insert(temp);
}
node *tree = DeleteMin();
char code[512];
code[0] = '\0';
print(tree,code, distinct_char);
}
答案 0 :(得分：1)
正如警告所示，你在这里错过了一个指针。 strcmp的签名读取
int strcmp(const char *s1, const char *s2);
但两个参数实际上都是char类型（数组索引从char生成char*，就像常规解引用一样，第二个参数是char反正）。
然而，你真正想要的是将字符串中的单个字符与另一个字符进行比较。您可以使用常规关系运算符：
if(str[i] == values[j]->a)
{
// ...
}
请注意，这只是回答您的确切问题，但无论如何您的代码可能是错误的或无效的。
答案 1 :(得分：0)
可能不完全＆＃34; on-topic＆＃34;，但如果您使用查找表方法，您的代码会得到显着改善。来自str的输入字符应该用作带字典的数组的索引 - 然后你只需要一个遍历输入字符串的循环。要处理char可以有256个值的事实，你只需要几个，你可以：
这样你就不会在你的代码中进行任何比较 - 只需索引（;