字符串算法集合（转）

 

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <malloc.h>
#define MAXLEN 100
#define N 80
//my_strlen
//计算字符串的长度函数的实现
int my_strlen(char *str)
{
 int i=0;
 char *pstr = 0;
 pstr = str;
 while(pstr[i])
 {
  i++;
 }
 return i;
}
//strcpy
//字符串的拷
void my_strcpy(char *des,char *scr)
{
 assert(des!=NULL&&scr!=NULL);
 while(*scr)
 {
  *des++=*scr++;
 }
 *des='/0';
}
//isalpha
//判断字符是否为字母函数的实现
int my_isalpha(int c)
{
 if((c>='A'&&c<='Z')||(c>='a'&&c<='z'))
 {
  return 1;
 }
 else
  return 0;
}
//isdigit
//判断字符是否为数字函数的实现
int my_isdigit(int c)
{
 if(c>='0'&&c<='9')
 {
  return 1;
 }
 else
  return 0;
}
//islower
//判断字符是否为小写字母函数的实现
int my_islower(int c)
{
 if(c>='a'&&c<='z')
 {
  return 1;
 }
 else
  return 0;
}
//tolower
//判断字符是否为大写字母函数的实现
char my_tolower(int c)
{
 if(c>='A'&& c<='Z')
 {
  c=c-32+'A'-1;
  return c;
 }
 else
 {
  return c;
 }
}
//toupper
//将小写字母转化大写字母
char my_toupper(int c)
{
 //判断字符是否为字母
 if(c>='A'&&c<='z')
 {
  //判断字符是否为小写字母
  if(c>='a'&&c<='z')
  {
   //将小写字母转化大写字母
   c=c-'a'+32;
   return c;
  }
  else
  {
   return c;
  }
 }
 else
 {
  return c;
 }
}
//strchar
//在字符串中查找某个字符
char *my_strchr(char *str,int c)
{
 while((*str!=c)&&(*str))
 {
  str++;
 }
 return (str);
}
//strcmp
//比较字符串大小函数的实现
int my_strcmp(char *s1,char *s2)
{
 int diffent = 0; 
  
 while(1){
  if(*s1 == '/0' && *s2 == '/0'){
   diffent = 0;
   break;
  }
    
   diffent = *s1 - *s2;
  if(diffent){
   break;
  }
      
  s1++;
  s2++;  
 } 
 
 return diffent;
}
//strcat
//字符串的连接函数的实现
char *my_strcat(char *target,const char *source)
{  
  char *original=target;
  while(*original != '/0')
   original++;     // Find the end of the string
  while(*source != '0')
   *original++=*source++;
  *original='/0';
  return(target);
}
//chrcnt
//计算某个字符在字符串出现的次数函数的实现
int my_chrcnt(char *sour,int letter)
{
 int count=0;
 while(*sour)
 {
  
  if(*sour==letter)
   count++;
  sour++;
 }
 return count;
}
//字符串插入算法
char *my_insert(char s[],char s1[],int i)
{
 int m,n,j,p=0;
 char *t;
 m=strlen(s);
 n=strlen(s1);
 t = (char *)malloc(m+n+1);
 memset(t,0,sizeof(t));
 if(i<1||i>m)
  printf("error./n");
 for(j=0;j<i-1;j++)
  t[p++]=s[j];
 for(j=0;j<=n-1;j++)
  t[p++]=s1[j];
 for(j=i-1;j<m;j++)
  t[p++]=s[j];
  
 t[p]='/0';
 return t;
}
//字符串删除算法
int my_del(char str1[],int i,int j,char str2[])
{
 int m,k,p=0;
 char *str = 0;
 m=strlen(str1);
 memset(str2,0,sizeof(str2));
 if(i+j>m)
  return 0;
 if (i >=j )
  return 0;
 str = str1;
 
 for(k=0;k<i-1;k++)
  str2[p++]=str[k];
 printf("1:%s/n",str2);
 for(k=i+j-1;k<m+1;k++)
  str2[p++]=str1[k];
 printf("2:%s/n",str2);
 str2[p]='/0';
 return 1;
}
//取子串算法
int get_subs(char str1[],int i,int j,char str2[])
{
 int m,k,p=0;
 m=strlen(str1);
 memset(str2,0,sizeof(str2));
 if(i+j>m)
  return 0;
 for(k=0;k<j;k++)
  str2[p++]=str1[i-1+k];
 str2[p]='/0';
 return 1;
}
//字符串查找算法
int my_search(char *str1,char *substr)
{
 char *p,*r;
 int n=0;
 char *str = str1;
 
 while(*str)
 {
  p=str;     //Ｐ指向父串
  r=substr;   //Ｒ指向子串
  while(*r)   //若子串不为空
  {
   if(*r==*p)  
   {
    r++;
    p++;
   }
   else
    break;
  }
  if(*r=='/0')
  {
   n++;
   //return str;
  }
  str++;
 }
 //if n = 0;
 return n;
}
//删除指定子串算法
char  *my_delsub(char *str,char *sub)
{
 char *p,*str2;
 char *t;
 int i=0;
 t=(char *)malloc(strlen(str));
 str2=str;
 p=sub;
 while(*str2)
 {
  while(*p)
  {
   if(*p==*str2)
     break;
     p++;
   
  }
  if(*p=='/0')
  {
   t[i]=*str2;
   i++;
  }
  str2++;
  p=sub;
 }
 t[i]='/0';
 str=t;
 return str;
}
//字符串替换算法
char  *my_replace(char *src,char *s1,char *s2)
{
 char *p;
 char *r;
 char *dstsrc =0;
 int srclen =0;
 
 char *str1 = src;
 srclen = strlen(src);
 while(*src)
 {
  p=str1;
  r=s1;
  while(*r)
  {
   if(*p==*r)
   {
    r++;
    p++;
   }
  else
   break;
  }
  if(*r=='/0')
  {
  
   break;
  }
  str1++;
 }
 if (str1 >= src +strlen(s2) -1)
  return 0;
 dstsrc = (char *)malloc(srclen + strlen(s2) -strlen(s1) + 1);
 memset(dstsrc,0,srclen + strlen(s2) -strlen(s1) + 1);
 p = src;
 r = dstsrc;
 while(p < str1)
 {
  *r++ = *p++;
 }
 int i;
 //替换字符
 for(i = 0;i<strlen(s2);i++)
  *r++=s2[i];
 p = str1 + strlen(s1);
 while(*p)
 {
  *r++ = *p++;
 }
 memset(src,0,srclen);
 strcpy(src,dstsrc);
 free(dstsrc);
 return src; 
}
char *huiwen(char *str)
{
 char *p1,*p2;
 int i,t=0;
 p1=str;
 p2=strlen(str)-1+str;
 for(i=0;i<strlen(str)/2;i++)
  if(*p1++!=*p2--)
    {
    t=1;
    break;
   }
  if(t==0)
   return ("yes,this string is huiwen.");
  else
   return ("no,this string is not huiwen.");
}
//把一个字符串中的字符（字母）按从小到大排序，并把这个全部
//由字母组成的字符串保存在原串中，函数返回这个字符串的长度
int fun(char *str)
{
 char *p;
 int j=0,k=0,m=0;
 int i=0;
 char t;
 p=str;
 //先统计字母，并把它放在ＳＴＲ中
 while(*p)
 {
  if((*p>='A'&&*p<='Z')||(*p>='a'&&*p<='z'))
   *(str+i++)=*p;
   p++;
 }
 *(str+i)='/0';
 p=str;
 //排序
 while(*(p+j))
 {
  k=j;
  m=j;
  while(*(p+k))
  {
   if(*(p+k)>*(p+m))
   {
    t=*(p+k);
    *(p+k)=*(p+m);
    *(p+m)=t;
   }
   k++;
  }
  j++;
 }
 return i;
}
//统计在str字符串中"a"到"z"26个字母各自出现的次数，并放在指定的数组中
void *funtotal(char *str,int pp[])
{
 char *p=str;
 int i;
 for(i=0;i<26;i++)
  pp[i]=0;
 while(*p)
 {
  if(*p>='a'&&*p<='z')
   pp[*p-'a']++;
   p++;
 }
}
//查找str中值为x的元素，返回该字符序列值为x的元素各个，并把这些值为x的元素下标依
//次在指的数组中
int fun_search(char *str,char ch)
{
  char *p=str;
  char *t;
  int i=0;
  int n=0;
  t=(char *)malloc(strlen(str));
  while(*p)
  {
    if(*p==ch)
     t[n++]=i;
    p++;
    i++;
  }
  return n;
}
//查找字符序列中０字符连续出现的最长长度，如果有几个０字符长度相同，只记录最后一个０字符的相关
//的相关信息，并返回最长０字符的长度和最后０的下标
int fun_search_string(char *str,int *m,int *k)
{
 char *p;
 int bb[N];
 int i,j;
 *m=0;
 *k=0;
 p=str;
 for(i=0;i<N;i++)
  bb[i]=0;
 i=0;
 while(*(p+i))
 {
  if(*(p+i)=='0')
  {
   bb[j]++;
   i++; 
  }
  else
  {
   j++;
   i++;
  }
  if(*m<bb[j])
  {
   *m=bb[j];
   *k=i-1;
  }
 }
}
char *my_memcopy(char *pvTo,char *pvFrom,size_t size)
{
 char *p=pvTo;
 char *q=pvFrom;
 while(size-->0)
  *pvTo++=*pvFrom++;
 return pvTo;
}
//按条件删除一个字符串指定字符一半的数目,如果字符串所包含的指定字符的个数是奇数,
//则不删除,如果是偶数,则删除
void fun_del_string1(char a[],char b[],char c)
{
 int i,j,m,n;
 i=0;
 j=0;
 n=0;
 m=0;
 while(a[i]!='/0')
 {
  if(a[i]==c)
   n++;
   i++;
 }
 i=0;
 if(n%2)
 {
  while(a[j]!='/0')
  {
   b[j]=a[j];
   j++;
  }
  b[j]='/0';
 }
 else
 {
  while(a[i]!='/0')
  {
    b[j++]=a[i];
    if(a[i]==c)
    m++;
    if(m>n/2&&a[i]==c)
     j--;
    i++;
  }
  b[j]='/0';
 }
}
//将s所指字符串下标为奇数的字符删除，串中剩余字符形成的新串放在所指数组中
void fun_del_string2(char *s,char t[])
{
 int i,k;
 int len;
 k=0;
 len=strlen(s);
 for(i=0;s[i]!='/0';i++)
  if(i%2==0)
   t[k++]=s[i];
   t[k]='/0';
}
//将s所指字符串除了下标为奇数、同时ＡＳＣＩ码值为偶数的字符外，其余的删除
void fun_del_string3(char *s,char t[])
{
 int i,k,len;
 k=0;
 for(i=0;s[i]!='/0';i++)
  if((i%2!=0)&&(s[i]%2==0))
  t[k++]=s[i];
  t[k]='/0';
}
//求字符串中最后一次出现的子字符串的地址
char  *fun_string_address(char *s,char *t)
{
 char *p,*r, *a;
 a=NULL;
 while(*s)
 {
  p=s;r=t;
  while(*r)
   if(*r==*p)
   {
     r++;
     p++;
   }
   else
    break;
   if(*r=='/0')
    a=s;
  s++;
 }
 return a;
}
//判断字符ch是否与所指字符串str中的某个字符相同；若相同，则什么做，若不同，则将其插在串的最后
void fun_search_same(char *str,char ch)
{
 while(*str&&*str!=ch)
  str++;
  if(*str=='/0')
  {
    str[strlen(str)-1]=ch;
    str[strlen(str)+1]='/0';
  }
}
//将字符串中的内容逆置
void fun_nizhi(char *s)
{
 int i,t,n=strlen(s);
 i=0;
 for(;i<n/2;i++)
 {
  t=*(s+i);
  *(s+i)=*(s+n-1-i);
  *(s+n-1-i)=t;
 }
}
//将所指字符串中每个单词的最后一个字母改成大写
void fun_convert_last_toupper(char *p)
{
 while(*p)
 {
  if(*p==' ')
  {
   *(p-1)=toupper(*(p-1));
   p++;
  }
  else
  p++;
 }
}
//删除字符串中所有的空格
void fun_del_space(char *str)
{
 int i,j;
 j=0;
 for(i=0;str[i]!='/0';i++)
  if(str[i]!=' ')
   str[j++]=str[i];
   str[j]='/0';
}
//把字符str下标为非素数从删除，把字符下标为素数的字符重新保存在str
char  *fun_shushu(char *str)
{
 int i,j,flag;
 int k;
 int len;
 char *p;
 p=str;
 len=strlen(str);
 k=0;
 for(i=0;i<len;i++)
 {
  if(i>1)
   str[k++]=str[i];
  flag=1;
  for(j=2;j<i&&flag;j++)
   if(i%j==0)
   {
    flag=0;
    k--;
   }
 }
 str[k]='/0';
 return str;
}
//将在字符串中s的字符按逆序存放到t中，然后把s的字符正序连接到串的后面
void  fun_connect(char *s,char *t)
{
 int i,len;
 char *p;
 p=s;
 len=strlen(s);
 for(i=0;i<len;i++)
  t[i]=s[len-1-i];
 for(i=0;i<len;i++)
  t[len+i]=s[i];
  t[2*len]='/0';
}
//从键输入一个字符串及一个指定字符，然后把这个字符及其后面的所有字符全部删除
char  *fun_del_string_after(char *str,char ch)
{
 int i;
 char *p;
 p=str;
 i=0;
 while(str[i]!='/0')
 {
  if(str[i]==ch)
   break;
  i++;
 }
 str[i]='/0';
 return str; 
}
//首先把Ｂ所指字符串中的字符接逆序存放，然后将Ａ所指字符串中的字符和Ｂ所指字符串中的字符，按排列的顺序交叉
//合并到C所指数组中去,过长的剩余字符接在C指数组的尾部.
char  *fun_hebing(char *a,char *b,char *c)
{
 int i,j;
 char ch;
 char *p;
 p=c;
 i=0;
 j=strlen(b)-1;
 while(i<j)
 {
  ch=b[i];
  b[i]=b[j];
  b[j]=ch;
  i++;
  j--;
 }
 while(*a||*b)
 {
  if(*a)
  {
   *c=*a;
   c++;
   a++;
  }
  if(*b)
  {
   *c=*b;
   c++;
   b++;
  }
 }
 *c='/0';
 return p;
}
//统计字符串各元音字母的个数,不分大小写
void fun_total_yuan_yin_leter(char *s,int num[5])
{
 int k,i=5;
 for(k=0;k<i;k++)
  num[k]=0;
 for(;*s;s++)
 {
  i=-1;
  switch(*s)
  {
   case 'a': case 'A':
    {
     i=0;
     break;
    }
   case 'e': case 'E':
    {
     i=1;
     break;
    }
   case 'i': case 'I':
    {
     i=2;
     break;
    }
   case 'o': case 'O':
    {
     i=3;
     break;
    }
   case 'u': case 'U':
    {
     i=4;
     break;
    }  
  }
 if(i>=0)
  num[i]++;
 }
}
//把字符串P中所有字符复制字符串B中,要求每复制3个字符之后插入一个空格.
void fun_insert_character(char *p,char *b)
{
 int i,k=0;
 while(*p)
 {
  i=1;
  //将前三个字符复制过去
  while(i<=3&&*p)
  {
   b[k]=*p;
   k++;
   i++;
   p++;
  }
  //插入空格
  if(*p)
  {
   b[k++]=' ';
  }
 }
 b[k]='/0';
}
//除了尾部＊号之外，将字符串其他的＊号全部删除，形参Ｐ指向字符串最后一个字符
void fun_del_singhao(char *a,char *p)
{
 int i;
 char *t=a;
 for(;t<=p;t++)
  if(*t!='*')
   *(a++)=*t;
 for(;*t!='/0';t++)
  *(a++)=*t;
  *a='/0';
}
//统计一行中单词的个数，作为函数值返回．一行字符串在主函数中输入
int fun_total_word(char *s)
{
 int i,j=0;
 for(i=0;s[i]!='/0';i++)
  if(s[i]!=' '&&s[i+1]!=' '||s[i+1]!='/0')
   j++;
 return j;
}
//删除字符串所有的星号
void fun_del_singhao1(char *a)
{
 int i,j=0;
 for(i=0;a[i]!='/0';i++)
  if(a[i]!='*')
   a[j++]=a[i];
  a[j]='/0';
}
//删除尾部的星号
void fun_del_singhao2(char *a)
{
 while(*a)
  a++;
 a--;
 while(*a=='*')
 a--;
 *(a+1)='/0';
}
//删除前面的星号
void fun_del_singhao3(char *a)
{
 char *p=a;
 while(*p=='*')
  p++;
 for(;*p!='/0';p++,a++)
  *a=*p;
  *a='/0';
}
//删除中间的星号
void fun_del_singhao3(char *a)
{
 
}
//主函数
int main()
{
 int n;
 n=my_search("askdaskaskdaskg","ask");
 printf("%d/n",n);
}