使用C语言提取子字符串及判断对称子字符串最大长度

先来看一个使用C语言从字符串中提取子字符串的基本方法总结：

#include 



int StrLenU(const char* string)
{
   int len = 0 ;
   const char* p = string;
   while(*p++ != '')
   {
     if(*p > 0x80 || *p < 0)
     {
      p++;
     }
     len++;
   }
   return len;
}

char* StrSetPosU(const char* string,int pos)
{
   char* result;
   result = string;
   while (result != NULL && *result != '' && pos > 1)
   {
     if(*result > 0x80 || *result < 0)
     {
result++;
     }
     result++;
     pos--;
   }
   if(pos!=0)
     return result;
   return '';
}

int StrLenMemU(const char* string,int size)
{  
   int len = 0 ;
   const char* p = string;
   while(*p++ != '' && size > 0)
   {
     if(*p > 0x80 || *p < 0)
     {
      p++;
      size--; 
     }
     size-- ;
     len++;
   }
   return len;
}

char* StringSubU(const char* string,int start,int number)
{
   int len = StrLenU(string) ;
   if(start>len)
   {
     printf("Start %d is too big than string length %d!n",start,len);
     return NULL;
   }
   int bufsize = 0;
   int num = number;
   const char* p = string;
   const char* start_char =string;
   
   p = StrSetPosU(string,start);
   start_char = p;
   
   if(number < 0)
   {
     while(*p != '')
     {
      p++;
      bufsize++;
     }
   }
   else
   {
     while(1)
     {
      
      if(*p == '' && num > 0)
      {
 printf("Number : %d is to big!n",number);
 break;
      }
      
      else if(num ==0 )
 break;
      
      if(*p > 0x80 || *p < 0)
      {
 bufsize++;
 p++;
      }
      bufsize++;
      p++;
      num--;
     }
   }
   num = bufsize;
   
   char* result ;
   result = (char*)malloc(sizeof(char)*(bufsize+1));
   memset(result,0,sizeof(char)*(bufsize+1));
   
   int i = 0;
   int j = 0;
   while(num != 0)
   {
     result[i++] = start_char[j++];
     num--;
   }
   
   result[bufsize] = '';
   return result;
}

int main()
{
   
   char* t = "a哈哈aab和c哈";
   printf("length: %dn",StrLenU("哈哈a哈a哈"));
   printf("指向前%sn指向后:%sn",t,StrSetPosU(t,3));
   printf("全字符时字符个数:%dn",StrLenMemU(t,6));
   printf("半个字符时字符个数:%dn",StrLenMemU(t,4)); 
   printf("1.正常取值:%sn",StringSubU("a哈aa哈a",1,2));
   printf("2.负值取值:%sn",StringSubU("a哈aa哈a",-1,2));
   printf("3.起始值过大:%sn",StringSubU("a哈aa哈a",7,2));
   printf("4.取值过大:%sn",StringSubU("a哈aa哈a",5,3));
   printf("5.负值取全部:%sn",StringSubU("a哈aa哈a",4,-1));

   return 0;
}

判断对称子字符串最大长度的方法

判断回文
先重写一个判断回文字串的方法，用指针实现，而不是数组了

  #include  
  #include  
  #include  
    
  void isSymmetrical(char *str) 
  { 
    char *begin, *end; 
    int flag, len = strlen(str); 
    
    for (begin = str, end = str + len - 1, flag = 1; begin <= end; begin ++, end --) { 
      if (*begin != *end) { 
 flag = 0; 
 break; 
      } 
    } 
    
    if (flag) 
      printf("Yes!n"); 
    else 
      printf("No!n"); 
  } 
    
    
  int main(void) 
  { 
    char str[1001]; 
    
    while (gets(str)) { 
      isSymmetrical(str); 
    } 
    
    return 0; 
  } 
    
  

判断回文子串
判断子串是否为回文，可以考虑从内向外比较。例如字符串“google”，如果我们判断第二个字符o是对称的，只需要再向左、和向右各移一位就可以判断下一个字符串是否是对称的了
需要注意的一点是，针对原字符串中的每一个字符有两种情况：

    以该字符为中心的对称分布，也就是回文子串为奇数
    以该字符和该字符前一个字符为中心的对称分布，也就是说回文子串是偶数

时间复杂度分析：

外层需要n - 1层循环，内层对于每个字符，都由中间向两边遍历一遍，为n，因此总的时间复杂度为O（n * n）

题目

    题目描述： 
    输入一个字符串，输出该字符串中对称的子字符串的最大长度。 
    比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 
    输入： 
    存在多组数据，每组数据一行字符串，长度不大于100。 
    输出： 
    输出回文子串的最大长度。 
    样例输入： 
    google 
    样例输出： 
    4 

ac代码

  #include  
  #include  
  #include  
    
   
  void maxSymmetricalSubstring(char *str) 
  { 
    int maxlength, len; 
    char *pre, *next, *current; 
      
    current = str + 1; 
    maxlength = 0; 
    
    while (*current != '') { 
      pre = current - 1; 
      next = current + 1; 
    
      while (pre >= str && *next != '' && *pre == *next) { 
 pre --; 
 next ++;   
      } 
    
      len = (next - 1) - (pre + 1) + 1; 
 
      if (len > maxlength) { 
 maxlength = len; 
      } 
    
      pre = current - 1; 
      next = current; 
    
      while (pre >= str && *next != '' && *pre == *next) { 
 pre --; 
 next ++; 
      } 
      len = (next - 1) - (pre + 1) + 1; 
    
      if (len > maxlength) { 
 maxlength = len; 
      } 
    
      current ++; 
    } 
      
    printf("%dn", maxlength); 
  }   
    
  int main(void) 
  { 
    char str[101]; 
    
    while (gets(str)) { 
      maxSymmetricalSubstring(str); 
    } 
    
    return 0; 
  }