学步园

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*******string库函数集合********/
int my_strlen(const char *str)
{
 int ret = 0;
 assert(str != NULL);
 while(*str++ != '\0')
  ++ret;
 return ret;
}
/*******不得自定义变量*********/
int my_strlen2(const char *str)
{
 if((*str) == '\0')
  return 0;
 else
  return (1 + my_strlen(++str));
}
//=========字符串查找=========//
char *my_strstr(char *strSrc, char *substr)
{
 int i, j;
 int lenstr, sublen;
 int num;
 if(strSrc == NULL || substr == NULL)
  return NULL;
 lenstr = strlen(strSrc);
 sublen = strlen(substr);
 if(lenstr < sublen)
  return NULL;
 num = lenstr - sublen;
 for(i = 0; i <= num; i++)
 {
  for(j = 0; j < sublen; j++)
  {
   if(strSrc[i+j] != substr[j])
    break;
  }
  if(j == sublen)
   return (strSrc + i);
 }
 return NULL;
}
char *my_strstr2(const char *strSrc, const char *str)
{
 assert(strSrc != NULL && str != NULL);
 const char *s = strSrc;
 const char *t = str;
 for(; *strSrc != '\0'; ++strSrc)
 {
  for( s= strSrc, t = str; (*t != '\0') && (*s == *t); ++s, ++t )
  {
  }
  if(*t == '\0')
   return (char *)strSrc;
 }
 return NULL;
}
//=========字符串拷贝=========//
char *my_strcpy(char *strDst, char *strSrc)
{
 if(strDst == strSrc)
  return strDst;
 assert( (strDst != NULL) && (strSrc != NULL) );
 char *address = strDst;
 while( (*strDst++ = *strSrc++) != '\0');
 return address;
}
char *my_strncpy(char *strDst, char *strSrc, int count)
{
 assert(strDst != NULL && strSrc != NULL);
 char *address = strDst;
 while((count--) && (*strSrc != '\0'))
  *strDst ++ = *strSrc++;
 *strDst = '\0';
 return address;
}
//==========字符串链接=========//
char *my_strcat(char *strDst, const char *strSrc)
{
 assert((strDst != NULL) && (strSrc != NULL));
 char *address = strDst;
 while(*strDst != '\0')
  ++ strDst;
 while((*strDst++ = *strSrc++) != '\0');
 return address;
}
char *my_strncat(char *strDst, const char *strSrc, unsigned int count)
{
 assert((strDst != NULL) && (strSrc != NULL));
 char *address = strDst;
 while(*strDst != '\0')
  ++strDst;
 while(count-- && *strSrc != '\0')
  *strDst++ = *strSrc++;
 *strDst = '\0';
 return address;
}
//=========将字符串所有替换成字符=========//
char *my_strset(char *str, int c)
{
 assert(str != NULL);
 char *s = str;
 for(; *s != '\0'; ++s)
  *s = (char)c;
 return str;
}
char *my_strnset(char *str, int c, unsigned int count)
{
 assert(str != NULL);
 char *s = str;
 for(; (*s != '\0') && ((s - str)<count); ++s)
  *s = (char) c;
 return str;
} 
//=====================================================
// 题目：比较2个字符串，用O(n)时间和恒量空间
//=====================================================
int my_strcmp(const char *str1, const char *str2)
{
 while((*str1 != '\0') && (*str2 != '\0') && (*str1 = *str2))
 {
  str1++;
  str2++;
 }
 return (*str1 - *str2);
}
int my_strncmp(const char *str1, const char *str2, unsigned int count)
{
 assert((str1 != NULL) && (str2 != NULL));
 while(*str1 && *str2 && (*str1 == *str2) && count--)
 {
  ++ str1;
  -- str2;
 }
 return (*str1 - *str2);
}
//===========查找字符出现的位置============//
char *my_strrchr(const char *str, int c)
{
 assert(str != NULL);
 const char *s = str;
 while(*s != '\0')
  ++ s;
 for(--s; *s != (char)c; --s)
 {
  if(s == str)
   return NULL;
 }
 return (char *)s;
}
//===========字符串的逆序============//
char my_strrev(char *str)
{
 assert(str != NULL);
 char *s = str, *t = str, c;
 while(*t != '\0')
  ++t;
 for(--t; s < t; ++s, --t)
 {
  c = *s;
  *s = *t;
  *t = c;
 }
 return str;
}
//=========字符串的切割==========//
char *my_strtok(char *strToken, const char *str)
{
 assert(str != NULL);
 static char *last;
 if(strToken == NULL && (strToken = last)==NULL)
  return (NULL);
 char *s = strToken;
 const char * t = str;
 while(*s != '\0')
 {
  t = str;
  while(*t != '\0')
  {
   if(*s == *t)
   {
    last = s + 1;
    if(s - strToken == 0)
    {
     strToken = last;
     break;
    }
    *(strToken + (s - strToken))= '\0';
    return strToken;
   }
   ++t;
  }
  ++s;
 }
 return NULL;
}
//=========内存拷贝========//
void my_memcpy(void *dst, const void *src, unsigned int num)
{
 assert((dst!=NULL) && (src != NULL));
 void *address = dst;
 while(num--)
 {
  *(char *)dst = *(char *)src;
  dst = (char *)dst + 1;
  src = (char *)src + 1;
 }
 return address;
}
//===========内存清零=========//
void *my_memset(void *str, int c, unsigned int count)
{
 assert(str != NULL);
 void *s = str;
 while(count --)
 {
  *(char *)s = (char)c;
  s = (char *)s + 1;
 }
 return str;
}
//=====================================================
// 题目：在给定的字符串中查找【由给定字符ch构成的】长度最长的串
// 分析：例如在abccdefaaag中长度最长的是aaa
// 返回值：查找串的首地址
//=====================================================
char *search_str_maxlen(char *strSrc, char ch)
{
 char *strTemp = NULL, *strDst = NULL;
 int iTemp, iCount = 0;
 while(*strSrc != '\0')
 {
  if((*strSrc) == ch)
  {
   iTemp = 0;
   strTemp = strSrc;
   while((*strSrc) == ch)
   {
    strSrc++;
    iTemp++;
   }
   if(iTemp > iCount)
   {
    iCount = iTemp;
    strDst = strTemp;
   }
   if((*strSrc)=='\0')
    break;
  }
  strSrc++;
 }
 return strDst;
}
//========================================================
// 题目：在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。
// 分析：这道题是2006 年google 的一道笔试题。
// 思路：将所有出现的字符的个数存储在数组a中
//========================================================
char first_single_char(char *str)
{
 int a[255];
 char *p = str;
 memset(a, 0, 255*sizeof(int));
 while(*p != '\0')
 {
  a[*p] ++;
  p++;
 }
 p = str;
 while((*p) != '\0')
 {
  if(a[*p] == 1)
   return *p;
 }
 return '\0';
}
花了一个下午，终于搞定。