C#自定义字符串替换Replace方法

前一阵遇到一个如标题的算法题，是将原有字符串的某些片段替换成指定的新字符串片段，例如将源字符串：abcdeabcdfbcdefg中的cde替换成12345，得到结果字符串：ab12345abcdfb12345fg，即：abcdeabcdfbcdefg -> ab12345abcdfb12345fg。

显然不能用string.Replace方法，需要自定义一个方法 string Replace(string originalString, string strToBeReplaced, string strToReplace),下面是我的实现代码，在半个小时内完成，通过了调试和常规数据的测试验证，还算是及格吧。

 public static string Replace(string originalString, string strToBeReplaced, string strToReplace)
         {
             string resultString = null;
             char[] originalCharArray = originalString.ToCharArray();
             char[] strToBeCharArray = strToBeReplaced.ToCharArray();
             char[] strToCharArray = strToReplace.ToCharArray();
             List<Char> newCharList = new List<Char>();

             for (int i = ; i < originalCharArray.Count(); i++)
             {
                 if (originalCharArray[i] == strToBeCharArray[])
                 {
                     bool IsReplace = false;
                     for (int j = ; j < strToBeCharArray.Count(); j++)
                     {
                         if (((i + j) < originalCharArray.Count())
                             && (originalCharArray[i + j] == strToBeCharArray[j]))
                         {
                             IsReplace = true;
                         }
                         else
                         {
                             IsReplace = false;
                             break;
                         }
                     }
                     if (IsReplace)
                     {
                         i += strToBeCharArray.Count() - ;
                         for (int k = ; k < strToCharArray.Count(); k++)
                         {
                             newCharList.Add(strToCharArray[k]);
                         }
                     }
                     else
                     {
                         newCharList.Add(originalCharArray[i]);
                     }
                 }
                 else
                 {
                     newCharList.Add(originalCharArray[i]);
                 }
             }

             resultString = string.Join("", newCharList);
             return resultString;
         }

因为有时间限制的要求，我没有添加注释，不过代码量不算多，逻辑也算简单清晰，没有注释也OK啦，缺点是算法复杂度比较高。下面经过本人同意，转载一下同事Hello Kitty同学对同一问题的实现代码, 也换一种思路来解决同一个问题。代码稍多，也添加了一些附加功能，各种注释也很完备，当然也需要花费更多时间。欢迎博友们有兴趣一同讨论此话题，请自由留言加以评论！ PS:就在刚才还发现了下面代码的一个bug，就当是隐藏彩蛋了！

 public class Replace
     {
         /// <summary>
         /// Replace 方法
         /// </summary>
         /// <param name="source">原字符串</param>
         /// <param name="find">需要查找的字符串</param>
         /// <param name="replace">替换的字符串</param>
         /// <returns>最终替换成功的字符串</returns>
         public string Replace(string source, string find, string replace)
         {
             // 要查找的字符串大于原来字符串,则不处理，返回原来字符
             if (find.Length > source.Length)
             {
                 return source;
             }

             // 记录找到多少次
             int findCount = ;
             // 仅用于标记，辅助记录多少次
             bool flag = true;
             // n：source字符串遍历的数值；j：find字符串遍历的数值
             int n = , j = ;
             // s：查找到字符串的开始索引，e：查找到字符串的结束索引
             int s = , e = ;

             while (true)
             {
                 // 判断字符是否相等
                 if (source[n] == find[j])
                 {
                     // Source 序列+1
                     n++;
                     // 判断是否为第一位相匹配
                     if (j == )
                     {
                         // 赋值给s，查找到头的索引
                         s = n;
                     }
                     // 查找到后下一次比较find的下一位
                     j++;
                     // 标记暂时找到前面相同的字符
                     flag = true;
                 }
                 else
                 {
                     // 记录不完全匹配
                     flag = false;
                     // find的索引归零
                     j = ;
                     // Source的索引继续想加
                     n++;
                 }

                 // 已经查找完毕
                 if (j == find.Length)
                 {
                     // 完全匹配
                     if (flag)
                     {
                         // 查找的字符数量+1
                         findCount++;
                     }
                     // 记录查找的数组结尾索引
                     e = n;
                     // source 索引继续+1
                     n++;
                     // find的索引归零
                     j = ;
                     // 计算生成新字符串，之后继续循环，直到替换所有字符串
                     source = GetNewString(source, find, replace, s, e);
                 }
                 // Source遍历完毕，则退出循环
                 if (n >= source.Length)
                 {
                     break;
                 }
             }
             // 最终字符串
             return source;
         }

         /// <summary>
         /// 获得新的字符串
         /// </summary>
         /// <param name="source">源字符串</param>
         /// <param name="find">需要查找的字符</param>
         /// <param name="replace">需要替换的字符</param>
         /// <param name="startIndex">查找到的字符开始索引</param>
         /// <param name="endIndex">查找到的字符结束索引</param>
         /// <returns>返回替换后的字符串</returns>
         public string GetNewString(string source, string find, string replace, int startIndex, int endIndex)
         {
             // 新字符串的长度
             int newArrayLength = source.Length + endIndex - startIndex;
             // 新字符数组
             char[] newStringArray = new char[newArrayLength];
             // 将前半部分复制给新字符串
             for (int i = ; i < startIndex - ; i++)
             {
                 newStringArray[i] = source[i];
             }
             // 当前临时开始索引
             int tempCurrentStartLength = startIndex - ;
             // 将需要替换的赋值给新的字符数组
             for (int i = tempCurrentStartLength; i < tempCurrentStartLength + replace.Length; i++)
             {
                 newStringArray[i] = replace[i - tempCurrentStartLength];
             }
             // 将之后剩余的字符赋值给新的数组
             for (int i = endIndex + ; i < newArrayLength; i++)
             {
                 newStringArray[i] = source[i - ];
             }
             // 返回转换后的字符串
             return string.Concat(newStringArray);
         }
     }