写几个字符串算法

1、实现strstr函数

函数原型是char *strstr(char *str1,char *str2);作用是找出str2字符串在str1字符串中第一次出现的位置（不包括str2的串结束符） 如果找到返回该位置的指针。若找不到，返回NULL指针。

const char * pstrstr(const char *haystack, const char *needle) { const char *p1, *p2; p1 = haystack; p2 = needle; while (*haystack != '/0' && *needle != '/0') { if (*haystack++ != *needle++) { needle = p2; haystack = ++p1; //从下一个字符开始搜索needle } } if (*needle == '/0') return p1; return NULL; }  

2、实现strcpy函数

 

char *strcpy(char *dest,char *src); 
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
src字符串尾的字符串结束标识符'/0'也会被复制过去，复制完成后s1中的内容会被覆盖掉

char * strcpy( char *strDest, const char *strSrc ) 
{
    assert( (strDest != NULL) && (strSrc != NULL) );
    char *address = strDest; 
    while( (*strDest++ = * strSrc++) != '/0' ); 
    return address;
}  

char *strncpy(char *strDes, const char *strSrc, unsigned int count)      
{      
    assert(strDes != NULL && strSrc != NULL);      
    char *address = strDes;      
    while (count-- && *strSrc != '/0')      
        *strDes++ = *strSrc++;   
    *strDes = '/0';  
    return address;      
}   
  
//查找字符串s中首次出现字符c的位置   
char *strchr(const char *str, int c)   
{   
    assert(str != NULL);   
    for (; *str != (char)c; ++ str)   
        if (*str == '/0')   
            return NULL;   
        return str;   
}   
  
int strcmp(const char *s, const char *t)   
{   
    assert(s != NULL && t != NULL);   
    while (*s && *t && *s == *t)   
    {   
        ++ s;   
        ++ t;   
    }   
    return (*s - *t);   
}   
  
char *strcat(char *strDes, const char *strSrc)   
{   
    assert((strDes != NULL) && (strSrc != NULL));   
    char *address = strDes;   
    while (*strDes != '/0')   
        ++ strDes;   
    while ((*strDes ++ = *strSrc ++) != '/0')   
        NULL;   
    return address;   
}   
  
int strlen(const char *str)   
{   
    assert(str != NULL);   
    int len = 0;   
    while (*str ++ != '/0')   
        ++ len;   
    return len;   
}   
  
//此函数，梦修改如下     
char *strdup_(char *strSrc)     
//将字符串拷贝到新的位置     
{     
    if(strSrc!=NULL)     
    {     
        char *start=strSrc;     
        int len=0;     
        while(*strSrc++!='/0')     
            len++;     
          
        char *address=(char *)malloc(len+1);     
        assert(address != NULL);  
          
        while((*address++=*start++)!='/0');      
        return address-(len+1);      
    }     
    return NULL;     
}     
  
//多谢laoyi19861011指正  
char *strstr(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)   
            NULL;   
        if (*t == '/0')   
            return (char *) strSrc;   
    }   
    return NULL;   
}   
  
char *strncpy(char *strDes, const char *strSrc, unsigned int count)      
{      
    assert(strDes != NULL && strSrc != NULL);      
    char *address = strDes;      
    while (count -- && *strSrc != '/0')      
        *strDes ++ = *strSrc ++;      
    *strDes = '/0';  
    return address;      
}      
  
  
char *strncat(char *strDes, const char *strSrc, unsigned int count)   
{   
    assert((strDes != NULL) && (strSrc != NULL));   
    char *address = strDes;   
    while (*strDes != '/0')   
        ++ strDes;   
    while (count -- && *strSrc != '/0' )   
        *strDes ++ = *strSrc ++;   
    *strDes = '/0';   
    return address;   
}   
  
int strncmp(const char *s, const char *t, unsigned int count)   
{   
    assert((s != NULL) && (t != NULL));   
    while (*s && *t && *s == *t && count --)   
    {   
        ++ s;   
        ++ t;   
    }   
    return (*s - *t);   
}   
  
char *strpbrk(const char *strSrc, const char *str)   
{   
    assert((strSrc != NULL) && (str != NULL));   
    const char *s;   
    while (*strSrc != '/0')   
    {   
        s = str;   
        while (*s != '/0')   
        {   
            if (*strSrc == *s)   
                return (char *) strSrc;   
            ++ s;   
        }   
        ++ strSrc;   
    }   
    return NULL;   
}   
  
int strcspn(const char *strSrc, const char *str)   
{   
    assert((strSrc != NULL) && (str != NULL));   
    const char *s;   
    const char *t = strSrc;   
    while (*t != '/0')   
    {   
        s = str;   
        while (*s != '/0')   
        {   
            if (*t == *s)   
                return t - strSrc;   
            ++ s;   
        }   
        ++ t;   
    }   
    return 0;   
}   
  
int strspn(const char *strSrc, const char *str)   
{   
    assert((strSrc != NULL) && (str != NULL));   
    const char *s;   
    const char *t = strSrc;   
    while (*t != '/0')   
    {   
        s = str;   
        while (*s != '/0')   
        {   
            if (*t == *s)   
                break;   
            ++ s;   
        }   
        if (*s == '/0')   
            return t - strSrc;   
        ++ t;   
    }   
    return 0;   
}   
  
char *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* 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 *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;   
}   
  
char *strset(char *str, int c)   
{   
    assert(str != NULL);   
    char *s = str;   
    for (; *s != '/0'; ++ s)   
        *s = (char) c;   
    return str;   
}   
  
char *strtok(char *strToken, const char *str)   
{   
    assert(strToken != NULL && str != NULL);   
    char *s = strToken;   
    const char *t = str;   
    while (*s != '/0')   
    {   
        t = str;   
        while (*t != '/0')   
        {   
            if (*s == *t)   
            {   
                *(strToken + (s - strToken)) = '/0';   
                return strToken;   
            }   
            ++ t;   
        }   
        ++ s;   
    }   
    return NULL;   
}   
  
char *strupr(char *str)   
{   
    assert(str != NULL);   
    char *s = str;   
    while (*s != '/0')   
    {   
        if (*s >= 'a' && *s <= 'z')   
            *s -= 0x20;   
        s ++;   
    }   
    return str;   
}   
  
char *strlwr(char *str)   
{   
    assert(str != NULL);   
    char *s = str;   
    while (*s != '/0')   
    {   
        if (*s >= 'A' && *s <= 'Z')   
            *s += 0x20;   
        s ++;   
    }   
    return str;   
}   
  
void *memcpy(void *dest, const void *src, unsigned int count)   
{   
    assert((dest != NULL) && (src != NULL));   
    void *address = dest;   
    while (count --)   
    {   
        *(char *) dest = *(char *) src;   
        dest = (char *) dest + 1;   
        src = (char *) src + 1;   
    }   
    return address;   
}   
  
void *memccpy(void *dest, const void *src, int c, unsigned int count)   
{   
    assert((dest != NULL) && (src != NULL));   
    while (count --)   
    {   
        *(char *) dest = *(char *) src;   
        if (* (char *) src == (char) c)   
            return ((char *)dest + 1);   
        dest = (char *) dest + 1;   
        src = (char *) src + 1;   
    }   
    return NULL;   
}   
  
void *memchr(const void *buf, int c, unsigned int count)   
{   
    assert(buf != NULL);   
    while (count --)   
    {   
        if (*(char *) buf == c)   
            return (void *) buf;   
        buf = (char *) buf + 1;   
    }   
    return NULL;   
}   
  
int memcmp(const void *s, const void *t, unsigned int count)   
{   
    assert((s != NULL) && (t != NULL));   
    while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count --)   
    {   
        s = (char *) s + 1;   
        t = (char *) t + 1;   
    }   
    return (*(char *) s - *(char *) t);   
}   
void *memmove(void *dest, const void *src, unsigned int count)   
{  
    assert(dest != NULL && src != NULL);  
    char* pdest = (char*) dest;  
    char* psrc = (char*) src;  
      
    //pdest在psrc后面，且两者距离小于count时，从尾部开始移动. 其他情况从头部开始移动  
    if (pdest > psrc && pdest - psrc < count)   
    {  
        while (count--)   
        {  
            *(pdest + count) = *(psrc + count);  
        }  
    } else   
    {  
        while (count--)   
        {  
            *pdest++ = *psrc++;  
        }  
    }  
    return dest;  
}  
  
void *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;   
}