数据结构---字符串

1. 翻转句子中单词的顺序，但单词内字符的顺序不变

思路：先逆转整个句子，然后从首字符开始扫描，每扫描到一个单词（遇到空白或结束字符），对这个单词进行逆转。

1.  void Reverse(char *pBegin, char *pEnd)  
2.  {  
3.      if(pBegin == pEnd)  
4.          return;  
5.      while(pBegin < --pEnd)  
6.      {  
7.          char tmp = *pBegin;  
8.          *pBegin = *pEnd;  
9.          *pEnd = tmp;  
10.         pBegin++;  
11.     }  
12. }  
13. void ReverseSentence(char *pSentence)  
14. {  
15.     if(pSentence == NULL)  
16.         return;  
17.   
18.     Reverse(pSentence, pSentence+strlen(pSentence));  
19.     char *pBegin = pSentence;  
20.     char *pEnd = pSentence;  
21.     while(*pEnd != '\0')  
22.     {  
23.         if(*pEnd != ' ')  
24.             pEnd++;  
25.         else  
26.         {  
27.             //遇到空格，逆转这个单词  
28.             Reverse(pBegin, pEnd);   
29.             pBegin = ++pEnd;  
30.         }  
31.     }  //循环结束时，pEnd指向句子末尾，pBegin指向最后一个单词开头位置
32.     //逆转最后一个单词  
33.     Reverse(pBegin, pEnd);  
34. } 

2. 字符串转换成整数

问题描述：输入一个表示整数的字符串，把该字符串转换成整数并输出。例如输入字符串”345”，则输出整数345。
思路：转换的过程比较简单，每次读入一个字符，将之前保存的值乘以10，然后再加上这个字符表示的数字。这是正常情况。这个问题主要是考察各种不正常情况的处理。假设函数的声明为 int StrToInt(const char *str);
（1）输入的字符串指针为空；
（2）数字前面有正负号的处理；
（3）字符串表示的数字超过了32位整数能表示的范围，即溢出处理；
（4）输入了非法字符，即除了数字及正负号的其他字符；
（5）以字符’ 0 ‘开始的串，’ 0 ‘后面还跟了其他字符，也是非法的。

如果能很好的处理这些情况，那么程序的健壮性大大增强。其中有两种情况处理起来有点麻烦，第一，如何处理溢出，我们可以使用std::numeric_limits::max()，可以定义一个long long的变量，然后与这个最大值相比，从而判断是否溢出了。第二。由于返回值为一个整型数，那么如果转换失败，返回什么呢？如果是’0 ’ ，那么就无法区分正常输入”0”的情况。两种方案，修改函数声明，通过返回值表明转换的成功与否，或者定义一个全局变量，用来保存转换的成功与否。参考代码中使用了第二种方案。

1.  bool strToIntOK; //全局的变量    
2.  int StrToInt(const char *str)    
3.  {    
4.      strToIntOK = false;    
5.      if(str == NULL)  //空指针    
6.          return 0;    
7.          
8.      if(str[0] == '0' && str[1] != '\0') //以'0'开始但不是"0" 这条其实可以忽略    
9.          return 0;    
10.         
11.     unsigned i = 0;    
12.     bool minus = false;    //负数标记    
13.     if(str[i] == '-' || str[i] == '+') //判断是不是以正负号开始    
14.     {    
15.         minus = (str[i] == '-')? true: false; //问号表达式   
16.         i++;    
17.     }    
18.         
19.     long long result = 0;  //转换的结果   
20.     while(str[i] != '\0')    
21.     {    
22.         char c = str[i++];    
23.         if(c >= '0' && c <='9')   //为数字 
24.         {    
25.             result = result * 10 + (c - '0');    
26.             if(minus) //负溢出  
27.             {  
28.                 if(result - 1 > numeric_limits<int>::max())   
29.                     return 0;    
30.             }  
31.             else //正溢出  
32.             {  
33.                 if(result > numeric_limits<int>::max())  
34.                     return 0;    
35.             }  
36.         }    
37.         else    
38.         {    
39.             return 0;    
40.         }    
41.     }    
42.     strToIntOK = true;    
43.     //结果返回 需强制转换一下    
44.     return minus? (int)(-result):(int)result;    
45. }
46. #include <limits>
47. numeric_limits<type>：
numeric_limits<type>::digits    type的位数。
numeric_limits<type>::max()    type的最大值。
numeric_limits<type>::min()    type的最小值

3. 在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。

思路：这一题不难，因为每个字符只有8位共256个，因此可以用计数法。首先统计字符串中每个字符的出现次数，然后从头遍历字符串，对于当前字符，查询统计表，如果出现的次数为1，则输出该字符即可。

1.  char FirstAppearOnce(char *pStr)  
2.  {  
3.      if(pStr == NULL)  
4.          return '\0'; //未找到返回空字符  
5.    
6.      int count[256] = {
  0};  //出现次数，所以用int
7.      char *pTmp = pStr;  
8.        
9.      while(*pTmp != '\0')  //统计字符串中每个字符出现的次数  
10.     {  
11.         count[*pTmp]++;  
12.         pTmp++;  
13.     }  
14.     while(*pStr != '\0') //遍历字符串，找到第一个只出现一次的字符  
15.     {  
16.         if(count[*pStr] == 1)  
17.             break;  
18.         pStr++;  
19.     }  
20.     return *pStr; //找到的字符  
21. }