题目马尔可夫链算法生成随机可读的文本

/*题目是：
输入一段文字，然后两个两个为前缀单词，后一个单词为后缀。保存起来。
然后输入前缀（两个单词），按前缀后缀表随机输出直到结尾。

思路就是建立哈希表 以两个单词（两个字符数组）为key值。
哈希的编码方式是用ASCII码的总和。
 */
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
/*全局数据成员*/

typedef struct wordNode{//文字节点
    char* thisWord; //此节点单词
    struct wordNode* next; //指向下一个单词节点
}wordNode;

typedef struct hashNode{//哈希表节点
    char* Key[2]; //key值
    int hasHowMany; //有多少个后缀
    wordNode* wordlist; //后缀链表
}hashNode;

const int MaxWordSize=45; //最大单词长度
const int StringSize=1000; //最大单词个数
const int oneWordSize=sizeof(char)*MaxWordSize; //一个单词的占内存大小
hashNode hashTable[StringSize]; //哈希表

/*函数声明*/
void initializeHashTable(hashNode* hashTable);//初始化哈希表
int countHashCode(char** headTwoWord);//根据Key计算哈希值
bool creatHashNode(int hashCode,char* key1,char* key2,char* thisWord);//设置一个hash节点
wordNode* creatWordNode(char* word);//创造一个单词节点
char* findSuffixByPrefix(char* firstWord,char* secondWord);//根据前缀找后缀
bool FindIfTrueHashCode(char* firstWord,char* secondWord,int hashCode,char* Suffix);//寻找是否有空位

/*主函数*/
int main(){
    srand((unsigned int)time(NULL)); //随机数种子
    initializeHashTable(hashTable); //初始化哈希表
    
    int hashCode=0;//哈希值
    int tempHasHowMany=0;//hasHowMany的临时寄存值
    wordNode* tempWordNode=NULL;//临时的文字节点
    char charTemp[MaxWordSize]; //当前单词寄存
    char charTemp_1[MaxWordSize]="";//单词寄存1
    char charTemp_2[MaxWordSize]="";//单词寄存2
    char* tempHaHa[2]; //计算哈希值用的临时字符串数组
    printf("请输入一段文字,请以一个单独的(end)作为结尾(注意是圆括号):\n");
    while(1){
        scanf("%s",charTemp);
        if(!strcmp(charTemp_1,"")) {strcpy(charTemp_1,charTemp);continue;}//低级错误，continue写成了break
        if(!strcmp(charTemp_2,"")) {strcpy(charTemp_2,charTemp);continue;}//临时前两个单词
        tempHaHa[0]=charTemp_1;
        tempHaHa[1]=charTemp_2;
        hashCode=countHashCode(tempHaHa);
        while(!creatHashNode(hashCode,charTemp_1,charTemp_2,charTemp)) //创建哈希节点，被占位返回false就到下一位继续创建
            hashCode++;
        printf("前缀%s %s\t\t后缀:%s\n",charTemp_1,charTemp_2,charTemp);
        strcpy(charTemp_1,charTemp_2);
        strcpy(charTemp_2,charTemp);//将单词往后传递

        if(!strcmp(charTemp,"(end)")) break;
    }

    char temp[MaxWordSize];
    while(1)
    {
        printf("\n请输入表中的两词前缀:");
        scanf("%s%s",charTemp_1,charTemp_2);
        if(!(findSuffixByPrefix(charTemp_1,charTemp_2)==NULL)) break;
        else printf("没有这个前缀请重新输入:");
    }
    printf("%s %s ",charTemp_1,charTemp_2);
    do{//不断往后添加单词直到(end)
        strcpy(temp,findSuffixByPrefix(charTemp_1,charTemp_2));
        strcpy(charTemp,temp);
        printf("%s ",charTemp);
        strcpy(charTemp_1,charTemp_2);
        strcpy(charTemp_2,charTemp);
    }while(strcmp(charTemp,"(end)"));
    printf("\n");
    system("pause");
}
/*流程函数*/
void initializeHashTable(hashNode* hashTable){
    for(int i=0;i<StringSize;i++){
        hashTable[i].wordlist=NULL;
        hashTable[i].Key[0]=NULL;
        hashTable[i].Key[1]=NULL;
        hashTable[i].hasHowMany=0;
    }
}

/*工具函数*/

char* findSuffixByPrefix(char* firstWord,char* secondWord){
    char* temp[2];
    char Suffix[MaxWordSize];
    int tempHashCode=0;
    temp[0]=firstWord;
    temp[1]=secondWord;
    tempHashCode=countHashCode(temp);
    while(!FindIfTrueHashCode(firstWord,secondWord,tempHashCode,Suffix))
    {
        tempHashCode++;
        if(tempHashCode>999||hashTable[tempHashCode].Key[0]==NULL)
            return NULL;
    }
    return Suffix;
}

bool FindIfTrueHashCode(char* firstWord,char* secondWord,int hashCode,char* Suffix){
    int tempHasHowMany;
    int randomSuffix;
    wordNode* tempWordNode;
    if(hashTable[hashCode].Key[0]!=firstWord||hashTable[hashCode].Key[0]!=firstWord){
        return false;
    }
    else
    {
        tempHasHowMany=hashTable[hashCode].hasHowMany;
        randomSuffix=rand()%tempHasHowMany;
        tempWordNode=hashTable[hashCode].wordlist;
        for(int i=0;i<randomSuffix;i++)
            tempWordNode=tempWordNode->next;
        strcpy(Suffix,tempWordNode->thisWord);
        return true;
    }
}


int countHashCode(char** headTwoWord){
    int countASCII=0;
    int j=0;
    char* temp;
    temp=headTwoWord[0]; //低级错误，一开始写的1
    for(int i=0;i<2;i++){
        while((*temp)!='\0'){
            countASCII+=*temp;
            temp++;
        }
        temp=headTwoWord[1];
    }
    return countASCII%997;
}

bool creatHashNode(int hashCode,char* key1,char* key2,char* thisWord){
    int tempHasHowMany=0;
    wordNode* tempWordNode=NULL;
    if(hashTable[hashCode].Key[0]==NULL){ 
        hashTable[hashCode].Key[0]=key1;
        hashTable[hashCode].Key[1]=key2;
        hashTable[hashCode].wordlist=creatWordNode(thisWord);
        hashTable[hashCode].hasHowMany++;
        return true;
    }
    else if(hashTable[hashCode].Key[0]==key1&&hashTable[hashCode].Key[1]==key2){
        tempHasHowMany=hashTable[hashCode].hasHowMany;
        tempWordNode=hashTable[hashCode].wordlist;

        for(int i=0;i<tempHasHowMany-1;i++)
            tempWordNode=tempWordNode->next;
        tempWordNode->next=creatWordNode(thisWord);
        hashTable[hashCode].hasHowMany++;//刚开始 忘记自增了;
        return true;
    }
    else return false;
}

wordNode* creatWordNode(char* word){
    wordNode* temp=NULL;
    temp=(wordNode *)malloc(sizeof(wordNode));
    temp->next=NULL;
    temp->thisWord=(char *)malloc(sizeof(char));//初级错误，开始直接让word赋值给thisWord了。结果值跟着变。
    strcpy(temp->thisWord,word);
    return temp;
}