在字符串中删除特定的字符

传说这是一道知名外企的笔试题

但是看了一些文章，都只是单纯的转了那个算法，弱弱的说一句，那个算法中把'\0'写成了'/0'，会导致在

while ('/0' != *pTemp)  
      {  
            hashTable[*pTemp] = 1;  
            ++ pTemp;  
      }  

这一步的时候，一直循环下去，直到系统中断。不过调试的时候发现了一个很有意思的事情，就是之前pTemp之前是指向aeiou，这就是传入的第二个参数，当遍历完这个参数之后，pTemp会继续指向栈中的下一个地址，也就是第一个参数they are students的地址，这个正好映证了《深入理解计算机系统》上的内容，也说明了这玩意是多么多么的不安全啊。

说了这么多，还是看看具体的这道题目吧。

---

题目：输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”。

首 先我们考虑如何在字符串中删除一个字符。由于字符串的内存分配方式是连续分配的。我们从字符串当中删除一个字符，需要把后面所有的字符往前移动一个字节的 位置。但如果每次删除都需要移动字符串后面的字符的话，对于一个长度为n的字符串而言，删除一个字符的时间复杂度为O(n)。而对于本题而言，有可能要删 除的字符的个数是n，因此该方法就删除而言的时间复杂度为O(n^2)。

这个算法我也弱弱的实现了一下，一会儿一起贴出来。

事 实上，我们并不需要在每次删除一个字符的时候都去移动后面所有的字符。我们可以设想，当一个字符需要被删除的时候，我们把它所占的位置让它后面的字符来填 补，也就相当于这个字符被删除了。在具体实现中，我们可以定义两个指针(pFast和pSlow)，初始的时候都指向第一字符的起始位置。当pFast指 向的字符是需要删除的字符，则pFast直接跳过，指向下一个字符。如果pFast指向的字符是不需要删除的字符，那么把pFast指向的字符赋值给 pSlow指向的字符，并且pFast和pStart同时向后移动指向下一个字符。这样，前面被pFast跳过的字符相当于被删除了。用这种方法，整个删 除在O(n)时间内就可以完成。

这一步其实还是蛮不好理解的，或者我太菜了，第一次没有理解清楚，看了调试的过程，才明白了，这段话是什么意思。这段话对应的就是下面这段代码

while ('\0' != *pFast)  
{  
      if(1 != hashTable[*pFast])  
      {  
           *pSlow = *pFast;  
            ++ pSlow;  
       }  
       ++pFast;  
}  

初始时，pFast和pSlow都指向 they are students 的第一个字符，之后如果pFast指向的不是要删除的字符(这是if判断的内容)，则pFast和pSlow一起移动，知道他们都指向e，这时候，不进入if，pFast继续移动，pSlow还是指向e，当pFast指向y的时候，进入if，这时候，就将pSlow指向的e，替换成了pFast指向的y，也就是这段话的含义。

接下来就是分析，如何更快的确定pFast指向的字符，是在要删除的字符集中，这里使用了Hash的思想。

接下来我们考虑如何在一个字符串中查找一个字符。当然，最简单的办法就是从头到尾扫描整个字符串。显然，这种方法需要一个循环，对于一个长度为n的字符串，时间复杂度是O(n)。

由 于字符的总数是有限的。对于八位的char型字符而言，总共只有28=256个字符。我们可以新建一个大小为256的数组，把所有元素都初始化为0。然后 对于字符串中每一个字符，把它的ASCII码映射成索引，把数组中该索引对应的元素设为１。这个时候，要查找一个字符就变得很快了：根据这个字符的 ASCII码，在数组中对应的下标找到该元素，如果为0，表示字符串中没有该字符，否则字符串中包含该字符。此时，查找一个字符的时间复杂度是O(1)。 其实，这个数组就是一个hash表。

完整的代码如下：

// 从str中，删除一个指定的字符
void deleteOneChar(char* str, char toBeDelete)
{
    if(str == NULL)  return;
    int length = strlen(str);
    char* p = str;
    // 遍历str，删除和toBeDelete相等的字符
    for(int i=0; str[i]!='\0'&&i<length; i++)
    {
        // 如果相等则用后面的元素进行覆盖
        if(str[i] == toBeDelete)
        {
                int j=i;
                for(; str[j]!='\0'&&j<length-1;j++)
                    str[j]=str[j+1];
                str[j]='\0';
        }
    }
    return;
}

// 使用第一种方法实现 复杂度O(n^2)
void deleteChars1(char* str,const char* chars)
{
    if(str==NULL)  return;
    if(chars == NULL) return;
    // 依次删除chars中的每一个元素
    for(int i=0; i<strlen(chars); i++)
        deleteOneChar(str,chars[i]);
    return;
}
// 使用第二种方法实现复杂度O(n)
void deleteChars2(char* pStrSource, const char* pStrDelete)  
{  
      if(NULL == pStrSource || NULL == pStrDelete)  
  
            return;  
  
      const unsigned int nTableSize = 256;  
      int hashTable[nTableSize];  
      memset(hashTable, 0, sizeof(hashTable));  
      const char* pTemp = pStrDelete;  
      while ('\0' != *pTemp)  
      {  
            hashTable[*pTemp] = 1;  
            ++ pTemp;  
      }  
      char* pSlow = pStrSource;  
      char* pFast = pStrSource;  
      while ('\0' != *pFast)  
      {  

            if(1 != hashTable[*pFast])  
            {  
                  *pSlow = *pFast;  
                  ++ pSlow;  
            }  
            ++pFast;  
      }  
      *pSlow = '\0';  
  
}  

int main()
{
    char* str = "they are students";
    char* p = (char*)malloc((strlen(str)+1)*sizeof(char));
    strcpy(p,str);
    const char*q = "aeiou";
    deleteChars2(p,q);
    cout<<p<<endl;


    free(p);
    p = NULL;

}