从第一个字符串中删去第二个字符串的所有字符的两种方法

例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”。

第一种思路：不可避免的是遍历第一个字符串，如果遍历一个字符，都需要去第二个字符串中查找其存不存在，那么复杂度会是O(nm)，当然由于字符数有限，所以m是个常量。关于查找速度最快的当然是hash表，对于8位字符，size=2^8足矣。

关于删除字符，后面的字符要往前移，如果每删除一个就移一次，O(n^2)这复杂度实在太高，仅用快慢指针就可以搞定，这个方法非常有用，比如求解循环链表。

初始化：快慢指针指向第一个字符

循环：如果快指针指的是不需要删除的字符，将值赋给慢指针所指的值后，快慢指针同时++;如果快指针指向待删除字符，那么直接++；

终止：快指针指向'\0'

第二种思路：仅利用快慢指针的思想得到结果。

两种方法对比，利用哈希表的方法明显比第二种方法简单。

[cpp]  view plain copy

1. #include <iostream.h>  
2.   
3. #define NUMBER 256  
4.   
5. void Delete(char *first, char *second)  
6. {  
7.     int i;  
8.     int hashtable[NUMBER];  
9.     for(i=0; i<NUMBER; i++)  
10.         hashtable[i]=0;  
11.   
12.     char *p=second;  
13.     while(*p)  
14.     {  
15.         hashtable[*p]=1;  
16.         p++;  
17.     }  
18.   
19.     char *slow=first;  
20.     char *fast=first;  
21.     while(*fast)  
22.     {  
23.         if(hashtable[*fast]==0)  
24.         {  
25.             *slow=*fast;  
26.             slow++;  
27.         }  
28.         fast++;  
29.     }  
30.     *slow='\0';  
31. }  
32.   
33. void main()  
34. {  
35.     char first[]="They are students.";  
36.     char second[]="aeiou";  
37.     Delete(first, second);  
38.     cout<<first<<endl;  
39. }  
40. //另外一种方法，仅仅利用快慢指针达到目的。
41. #include <iostream>
    
    
    #define NUMBER 256
    
    
    using namespace std;
    
42. char firstArray[] = "They are students.";
    char secondArray[] = "aeiou";
    const int firstSize = sizeof firstArray / sizeof *firstArray;
    const int secondSize = sizeof secondArray / sizeof *secondArray;
    
    
    bool flag[NUMBER];
    
    
    void deleteArray(char *firstArray, char *secondArray)
    {
    if(firstArray == NULL || secondArray == NULL)
    return;
    
    
    for(int i = 0; i < NUMBER; i++) {
    flag[i] = false;
    }
    
    
    for( i = 0; i < secondSize; i++) {
    int pos = static_cast<int>(secondArray[i]);
    flag[pos] = true;
    }
    
    
    char *fast = firstArray, *slow = firstArray;
    
    
    while(*fast != '\0') {
    if(flag[*fast] == false) {
    *slow = *fast;
    slow++;
    }
    fast++;
    }
    *slow = 0;
    }
    
43. void main()
    {
    deleteArray(firstArray, secondArray);
    cout << firstArray << endl;
       
    }
    
44. //第三种比较简单的方法：没有利用快慢指针，但是同样达到了目的。

45. #include <iostream>
    #include <cstring>
    
    char * string_del_characters( char * const src, const char * const dest )
    {
       int destLen = strlen( dest );
       int hash_table[256] = { 0 };
       char * p = src;
       int index = 0;
       for( int i = 0; i < destLen; i++ )
       {
          hash_table[ (int)dest[i] ] = 1;
       }
       while( *p != '\0' )
       {
          if( 0 == hash_table[(int)*p] )
          {
             src[index++] = *p;
          }
          p++;
       }
       src[index] = '\0';
       return src;
    }
    
    int main( int argc, char ** argv )
    {
       char src[] = "They are students.";
       char dest[] = "aeiou";
       char * pResult = string_del_characters( src, dest );
       std::cout << pResult << std::endl;
    }