求助！全志科技2014招聘的一道笔试题，求解答！

Jen_Daniel

用C实现一个函数，函数原型为：
int strreplace(char *origin,char *target,char *rpl);
要求：把字符串origin中的target字符串全部替换成rpl，最后输出得到的新数组，设定所有的参数字符串长度不超过1024.

tsembrace

1. #include<stdio.h>
   
2. #include<string.h>
   
3. int th(char *a,char *b,char *c)
   
4. {
   
5.         int len1=strlen(a);
   
6.         int len2=strlen(b);
   
7.         int i,j,k,m,count;
   
8.         i=j=0;                                //两字符串游标
   
9.         count=0;                        //计数器
   
10.         while(i!=len1)
    
11.         {
    
12.                 j=0;                        //每次循环都从b[0]开始找起
    
13.                 count=0;                //重置计数器
    
14.                 if(a[i]!=b[j])
    
15.                 {
    
16.                         i++;
    
17.                         continue;
    
18.                 }                                //不等则找a中下一个字符
    
19.                 else
    
20.                 {
    
21.                         while(count!=len2)
    
22.                         {
    
23.                                 if(a[i]==b[j])               
    
24.                                 {
    
25.                                          i++;
    
26.                                          j++;
    
27.                                          count++;
    
28.                                 }                //如果相同就一直找
    
29.                                 else
    
30.                                         break;  //不同则退出当前小循环
    
31.                         }
    
32.                         if(count==len2) //如果计数器等于b长度，则替换
    
33.                         {
    
34.                                 m=len2-1;
    
35.                                 for(k=i-1;k>=(i-count);k--)
    
36.                                 {
    
37.                                         a[k]=c[m];
    
38.                                         m--;
    
39.                                 }
    
40.                         }
    
41.                        
    
42.                 }
    
43.         }
    
44.         printf("%s\n",a);
    
45.         return 1;
    
46. }
    
47. int main()
    
48. {
    
49.         char a[]="aa1abc1ilovecjabc1xxxaabclovecabc1jababc1";
    
50.         char b[]="abc1";
    
51.         char c[]="xyz2";
    
52.         th(a,b,c);
    
53. 
    
54.         return 0;
    
55. }
    
56. 
    
57.                        
    

复制代码

Jen_Daniel

tsembrace 发表于 2013-9-15 21:29

                               
登录/注册后可看大图

你这样只能在被替换和替换的字符串长度相等的时候才可以的，如果不相等呢？

awen162

我也来贴下自己的代码，代码写的有点乱，高手飘过。
这个题主要就是方法（可以说是算法）和思路，代码挺简单的，我就不做过多的注释了。有不明白的就问我把:lol:

本人也是小菜鸟，希望大牛能把自己好的思路和代码发上来，一起分享和讨论！

奉上自己凌乱的代码：

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. int main()
   
5. {
   
6.       int strreplace(char *origin,char *target,char *rpl);
   
7.       char o[1024], t[1024], r[1024];
   
8.       int count;                //计算替代的个数
   
9.       printf("请输入源字符串：\n");
   
10.       scanf("%s", o);
    
11.       printf("请输入被替换的字符串：");
    
12.       scanf("%s", t);
    
13.       printf("请输入需要替换字符串：");
    
14.       scanf("%s", r);
    
15. 
    
16.       count = strreplace(o, t, r);
    
17.       printf("新的字符串为：\n");
    
18.       printf("%s\n", o);
    
19.       printf("共有：%d处被替换了!\n", count);
    
20.       return 0;
    
21. }
    
22. 
    
23. int strreplace(char *origin,char *target,char *rpl)
    
24. {
    
25.       int count, i, j, k, len_origin,len_target, len_rpl, local;   // local定位temp中的位置
    
26.       char temp[1024];
    
27.       
    
28.       len_origin = strlen(origin);
    
29.       len_target = strlen(target);
    
30.       len_rpl = strlen(rpl);
    
31.       count = 0;
    
32.       local = 0;
    
33.       
    
34.       if(len_origin < len_target)
    
35.       {
    
36.             printf("被替换的字符串长度大于原字符串，不能替换!!\n");
    
37.             return 0;
    
38.       }
    
39.       
    
40.       i = 0;
    
41.       while(origin[i])   
    
42.       // 如果最后一个字符相同于target，数组引用是有可能超界，但测试没出错
    
43.       {
    
44.             for(j = 0; j < len_target; j++)
    
45.             {
    
46.                   if(origin[i+j] != target[j])
    
47.                         break;
    
48.             }
    
49.             if(len_target != j)     //判断
    
50.             {
    
51.                   temp[local] = origin[i];   //不相同就复制到temp中
    
52.                   local++;
    
53.             }
    
54.             else
    
55.             {
    
56.                   for(k = 0; k < len_rpl; k++)
    
57.                   {
    
58.                         temp[local] = rpl[k];     //将替换内容复制到temp中
    
59.                         local++;
    
60.                   }
    
61.                   count++;
    
62.                   i = i + j - 1;                 //i指向替换的最后一个对象
    
63.             }
    
64.             i++;
    
65.       }
    
66.       temp[local] = '\0';     // temp最后需要'\0'来结尾
    
67.       
    
68.       for(i = 0; temp[i]; i++)  // 将temp复制到origin上
    
69.       {
    
70.             origin[i] = temp[i];
    
71.       }
    
72.       origin[i] = '\0';       // origin也需要以'\0'结尾，origin后面如果有内容也被忽略
    
73. 
    
74.       return count;
    
75. }
    

复制代码

wangjie5540

先提供一下思路（只是个人思路）
1、早源字符串里面找到要替换的位置 利用strstr
2、创建临时的buf，把target之前的字符串先拷贝
3、在buf里添加要替换的字符串
4、把去掉target之后的那段也加到buf后面

之后就是循环去找target，循环操作

这个算法没有进行过效率的考究，所以现在只是自我建议

wangjie5540

1. #include "stdio.h"
   
2. 
   
3. int strreplace(char *origin,char *target,char *rpl)
   
4. {
   
5.     char* p = NULL;
   
6.     char tmpBuf[1024] = {0};
   
7.     char outPutBuf[1024] = {0};
   
8.     int offset = 0;
   
9.     char* tmporigin;
   
10. 
    
11.     if (strlen(origin) > 1024)
    
12.         return -1;
    
13.     if (strlen(target) > 1024)
    
14.         return -1;
    
15.     if (strlen(rpl) > 1024)
    
16.         return -1;
    
17. 
    
18.     strcpy(outPutBuf, origin);
    
19.     while (1){
    
20.         p = strstr(outPutBuf, target);
    
21.         if (!p)
    
22.             break;
    
23.         offset = p - outPutBuf;
    
24.         strncpy(tmpBuf, outPutBuf, offset);
    
25.         strncpy(tmpBuf + offset, rpl, strlen(rpl));
    
26.         strncpy(tmpBuf + offset + strlen(rpl), p + strlen(target), strlen(p + strlen(target)));
    
27.         strcpy(outPutBuf, tmpBuf);
    
28.     }
    
29.     strcpy(origin, outPutBuf);
    
30. }
    
31. int main()
    
32. {
    
33.     char a[1024] = "12345678";
    
34.     char b[1024] = "56";
    
35.     char c[1024] = "000";
    
36.     strreplace(a, b, c);
    
37.     printf("a = %s\n", a);
    
38.     return 0;
    
39. }

复制代码

代码如下，已经测试过了， 不过效率肯定不高。


这样的题个人感觉 更好是用链表，因为容易增删