Question

程序基本上搜索给定单词列表中的字符串，这些字符串是从终端输入的单词的字谜。它遵循算法：

对列表中的所有字词进行排序
计算已排序单词的哈希值，以便所有字谜具有相同的哈希值
创建哈希表并通过存储哈希值，排序后的单词和实际单词
通过检查哈希表

现在的问题是它在我的机器上运行完美但在其他人的计算机上运行不正常。我在这里包含代码并提供wordlist的链接。我知道要求你们下载单词列表然后编译和检查是太多了，但如果你让我知道它会意味着很多。我正在使用2.6.38-13-generic-pae运行Ubuntu 11.04

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

typedef struct x
{
int hashvalue;
char dictword[100];
char ascending[100];
struct x *next;
} node;

char *sortWord(char *);
//double fact(int);
void main()
{
FILE *fp1, *fp2;
char ch1;
while(ch1!='q')
{   
char *dictsort;
dictsort=(char *)malloc(100*sizeof(char));  
fp1=fopen("wordlist.txt", "r");
char ch;
int i=0;
char *sortedword;
int hashindex;
long int n;
printf("Please enter size of hashtable or press Ctrl+C to break:\n");
scanf("%ld", &n);


 node *hashtable[n];
 node *temp;
 char test1[50];
char *test;     
printf("Please enter the word to find anagrams for:\n");
scanf("%s", test1);
test=sortWord(test1);
int testhash=hashfunction(test);
printf("Hash value of word is %d\n", testhash);
for(i=0;i<1000000;i++)
{
    hashtable[i]=NULL;
}
temp=NULL;
while(!feof(fp1))
{   //printf("Seg fault here...\n");        
    //ch=getc(fp1);     
    fgets(dictsort, (100*sizeof(char)),fp1);
    //puts(dictsort);

    sortedword=(char *)malloc(sizeof(dictsort));
    sortedword = sortWord(dictsort);
    hashindex=hashfunction(sortedword);


    if(hashtable[hashindex]==NULL){ 

        hashtable[hashindex] = (node *)malloc(sizeof(node));
        strcpy(hashtable[hashindex]->dictword,dictsort);
        strcpy(hashtable[hashindex]->ascending,sortedword);
        hashtable[hashindex]->hashvalue=hashindex;
        hashtable[hashindex]->next=NULL;        
    }else{

        temp = (node *)malloc(sizeof(node));
        strcpy(temp->dictword,dictsort);
        strcpy(temp->ascending,sortedword);
        temp->hashvalue=hashindex;
        temp->next=hashtable[hashindex];
        hashtable[hashindex]=temp;
    //  free(temp);             
    }
    //printf("%s", hashtable[hashindex]->dictword);
    free(sortedword);

}

//for(i=0;i<100000;i++)
//{ 
    node *print;
    print=(node *)malloc(sizeof(node));
    print=hashtable[testhash];
    int chk;        

    while(print!=NULL)
    {
        chk=strcmp(print->ascending,test);
        if(chk==0)              
            {
                printf("%s\n", print->dictword);
                print=print->next;
            }   

        else
        print=print->next;
    }



    free(print);

}
}

int hashfunction(char *sw){

int a=0,i=0;
int k,b,c;
int div=1000000;
int blah;
int hv;     
for(i=0;sw[i]!='\0';i++){

    a=sw[i];
    //b=sw[i+1];
    //c=sw[i+2];        
    if(a!=10&&b!=10)
    {
        k=a*fact(i);
        b=k;            

        hv+=b;  
    }

}
hv=hv%div;  
return hv;

}

char *sortWord(char *s)
{
int c, d = 0, length;
char *pointer, *result, ch;
FILE *fp;
length = strlen(s);

result = (char*)malloc(length+1);

pointer = s;

for ( ch = 'a' ; ch <= 'z' ; ch++ )
{
        for ( c = 0 ; c < length ; c++ )
        {
            if ( *pointer == ch )
            {
                    *(result+d) = *pointer;
                    d++;
            }
        pointer++;
            }
    pointer = s;
}
*(result+d) = '\0';
char *z;
z=(char *)malloc(length+1);
strcpy(z, result);

//fp=fopen("sortedlist.txt", "a");
//fprintf(fp, "%s\n", s);

//fclose(fp);

free(result);

//puts(s);
//return result;
return z;   
//free(result); 


}

int fact(int num)
{
int i;
int val=1;
for(i=num+1;i>=1;i--)
{
    val=val*i;
}

return val%1000000;
}

Answer 1

在很多其他事情中：

 int hv;
 /* ... */
 hv+=b;

hv永远不会被初始化。（同一个函数中不是对象b，而且对象ch1不是main函数。）

Answer 2

另外

node *hashtable[n];
// ...
printf("Hash value of word is %d\n", testhash);
for(i=0;i<1000000;i++)
{
    hashtable[i]=NULL;
}

如果n < 1000000怎么办？如果它更大会怎么样？

除此之外，大型VLA可能会在许多系统上溢出堆栈。

Answer 3

将来，请务必使用所有（或几乎所有）编译器的警告标志进行编译。 “未经初始化的变量读取”是一个非常常见的错误，大多数编译器都会警告过你......

C程序在我的计算机上编译和运行，但不在其他机器上运行

3 个答案: