c中字符串与字符数组的比较

Question

我正在尝试编写用于编码和解码目的的代码。一旦我们有了字典，形成的字典就会存储在结构数组中。结构如下

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);
  

}

Answer 1

正如警告所暗示的，您在这里缺少一个指针。 strcmp的签名写着

int strcmp(const char *s1, const char *s2);

但是这两个参数实际上都是char 类型（数组索引从char* 生成char，就像常规取消引用一样，第二个参数无论如何都是char）。

但是，您真正想要的是将字符串中的单个字符与另一个字符进行比较。您可以只使用常规的关系运算符：

if(str[i] == values[j]->a) 
{
    // ...
}

请注意，这只是回答您的确切问题，但您的代码可能是错误的或无效的。

Answer 2

也许不是完全“切题”，但如果您使用查找表方法，您的代码会显着改进。输入字符 - 来自 str 应该用作带有字典的数组的索引 - 然后您只需要一个遍历输入字符串的循环。要处理 char 可以有 256 个值的事实，您只需要其中几个即可：

• 仅使用部分 char 值作为索引 - 在实际索引之前减去一些值（您希望编码的第一个可打印字符）并将结果与​​ LUT 中的最大索引进行比较，
• 浪费一些内存并在 LUT 中包含所有 256 个索引，
• 使用另一个 LUT 将字符从输入转换为 LUT 中的索引 - 这样您就可以将所有不支持的字符映射到一个通用输出元素，
• ...

这样您就不会在代码中进行任何比较 - 只需索引 (;