剑指 Offer II 063. 替换单词 -c语言空间效率最高算法

剑指 Offer II 063. 替换单词 -c语言空间效率最高算法

在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。

现在，给定一个由许多词根组成的词典和一个句子，需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。

需要输出替换之后的句子。

示例 1：

输入：dictionary = [“cat”,“bat”,“rat”], sentence = “the cattle was rattled by the battery”
输出：“the cat was rat by the bat”

示例 2：

输入：dictionary = [“a”,“b”,“c”], sentence = “aadsfasf absbs bbab cadsfafs”
输出：“a a b c”

示例 3：

输入：dictionary = [“a”, “aa”, “aaa”, “aaaa”], sentence = “a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa”
输出：“a a a a a a a a bbb baba a”

示例 4：

输入：dictionary = [“catt”,“cat”,“bat”,“rat”], sentence = “the cattle was rattled by the battery”
输出：“the cat was rat by the bat”

示例 5：

输入：dictionary = [“ac”,“ab”], sentence = “it is abnormal that this solution is accepted”
输出：“it is ab that this solution is ac”

解题代码如下：

void  quick_sort(int* len,int* s,int low ,int high){
    int l=low,h=high;
   
    
    if(low<high){
         int pivat=len[low];
         int  p=s[low];
        while(low<high){
             while(len[high]>=pivat&&low<high){
                high--;
            }
            len[low]=len[high];
            s[low]=s[high];

            while(len[low]<=pivat&&low<high){
                low++;
            }
            len[high]=len[low];
            s[high]=s[low];
        }
        len[low]=pivat;
        s[low]=p;
          quick_sort(len,s,l,low-1);
         quick_sort(len,s,low+1,high);

    }
  
}
int scmp(char *a,char *b,int len){
    int i=0;
    // printf("--%d ",len);
    // printf("%s ",a);
    // printf("%s ",b);
   //  printf(" %d %d ",strlen(a),strlen(b));
   
    if(strlen(a)>=strlen(b)){
        return 0;
    }
    while(a[i]==b[i]){
        i++;
        if(i==len)
           break;
        // printf("%d ",i);
    }
    if(i==len) return 1;
    else return 0;
}

char * replaceWords(char ** dictionary, int dictionarySize, char * sentence){
    int *len=(int *)malloc(sizeof(int)*dictionarySize);
    char *sr=(char *)malloc(sizeof(char)*1000);
    int i=0;
    int *s=(int *)malloc(sizeof(int)*dictionarySize);
    for(i=0;i<dictionarySize;i++){
        len[i]=strlen(dictionary[i]);
        s[i]=i;
       // printf("%d ",len[i]);
    }
  //  sentence[10]='\0';
 
 // printf("s ");
    quick_sort(len,s,0,dictionarySize-1);
    //  printf("s2 ");
    //  for(i=0;i<dictionarySize;i++){
      
    //     printf("%d ",len[i]);
    // }
    
    int z;
    i=0;
    int j;
    int p;
    int r=0;
    int d;
    while(sentence[i]!='\0'){
     //   printf(" d");
        if(sentence[i]!=' '){
            j=i;
            p=0;
            while(sentence[j]!=' '&&sentence[j]!='\0'){
                sr[p++]=sentence[j];
                j++;
            }
            sr[p]='\0';
             
            d=0;
           // printf(" --%d ",len[d]);
          //  printf("%d ",s[d]);
            while(scmp(dictionary[s[d]],sr,len[d])!=1){
            
                d++;
                if(d==dictionarySize)
                break;
            }
      //      printf("sd");
       //  printf("&%d ",r);
             
            if(d==dictionarySize){
            
                while(i!=j){
                    sentence[r++]=sentence[i++];
                }
            }
            else{
                z=i;
                  while(i!=z+len[d]){
                    sentence[r++]=sentence[i++];
                }

            }

       
            i=j;
            


        }
        else{
            i++;
            sentence[r++]=' ';
        }

    }
  //  printf("  ii%d ",r);
   // printf("%s ",sentence);
 //   printf("%c ",sentence[r]);
    sentence[r]='\0';
  //  printf("%s ",sentence);

return sentence;
}

代码看似复杂，其实就是正常思路，感兴趣的可以跟我了解一下