字符串处理

最新推荐文章于 2022-11-12 22:28:19 发布
最新推荐文章于 2022-11-12 22:28:19 发布
阅读量218 收藏
点赞数
分类专栏： 最新学习 文章标签： null dst string c 面试 测试

第一节、字符串查找

1.1题目描述：

给定一个字符串A，要求在A中查找一个子串B。

如A="ABCDF"，要你在A中查找子串B=“CD”。

分析：比较简单，相当于实现strstr库函数，主体代码如下：

 

//在字符串中查找指定字符串的第一次出现，不能找到则返回-1     

int strstr(char *string, char *substring)     

{    

    if (string == NULL || substring == NULL)       

        return -1;       

     

    int lenstr = strlen(string);    

    int lensub = strlen(substring);    

     

    if (lenstr < lensub)       

        return -1;        

     

    int len = lenstr - lensub; 

    for (int i = 0; i <= len; i++)   //复杂度为O(m*n)    

    {    

        for (int j = 0; j < lensub; j++)    

        {    

            if (string[i+j] != substring[j])    

                break;    

        }    

        if (j == lensub)    

            return i + 1;    

    }    

    return -1;    

}   

 

    上述程序已经实现了在字符串中查找第一个子串的功能，时间复杂度为O（n*m），也可以用KMP算法，复杂度为O(m+n)。具体的，在此不再赘述。

    希望此狂想曲系列能给各位带来的是一种方法，一种创造力，一种举一反三的能力，而不是机械的只是为大家提供答案。那样的话，一切永远都只是邯郸学步，你我都无从进步（而这同时却是许多所谓的面经或面试宝典之类的书很乐意做的事，有点不解）。

    为人打通思路，提高他人创造力，我想，这是狂想曲与其它的面试解答所不同的地方，也是我们写狂想曲系列文章的意义与价值之所在。

1.2、题目描述

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

代码则可以如下编写：

 

//查找第一个只出现一次的字符，       

char FirstNotRepeatChar(char* pString)    

{    

    if(!pString)    

        return '/0';    

     

    const int tableSize = 256;   

    //有点要提醒各位注意，一般常数的空间消耗，如这里的256，我们也认为此空间复杂度为O（1）。 

    int hashTable[tableSize] = {0}; //存入数组，并初始化为0    

     

    char* pHashKey = pString;    

    while(*(pHashKey) != '/0')    

        hashTable[*(pHashKey++)]++;    

     

    while(*pString != '/0')    

    {    

        if(hashTable[*pString] == 1)    

            return *pString;    

         

        pString++;    

    }    

    return '/0';  //没有找到满足条件的字符，退出    

}   

 

代码二，bitmap：

 

# include<stdio.h> 

# include<string.h> 

 

const int N = 26; 

int bit_map[N]; 

 

void findNoRepeat(char *src) 

{ 

    int pos; 

    char *str = src; 

    int i ,len = strlen(src); 

     

    //统计 

    for(i = 0 ; i < len ;i ++) 

        bit_map[str[i]-'a'] ++; 

     

    //从字符串开始遍历 其bit_map==1 那么就是结果 

    for(i = 0 ; i < len ; i ++) 

    { 

        if(bit_map[str[i]-'a'] == 1) 

        { 

            printf("%c",str[i]); 

            return ; 

        } 

    } 

} 

 

int main() 

{    

    char *src = "abaccdeff"; 

    findNoRepeat(src); 

    printf("/n"); 

    return 0; 

} 

 

 

第二节、字符串拷贝

题目描述：

要求实现库函数strcpy，

原型声明：extern char *strcpy(char *dest,char *src);

功能：把src所指由NULL结束的字符串复制到dest所指的数组中。 　

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 　

返回指向dest的指针。

 

    分析：如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：

 

//得2分    

void strcpy( char *strDest, char *strSrc )    

{    

    while( (*strDest++ = * strSrc++) != '/0' );    

}     

 

//得4分    

void strcpy( char *strDest, const char *strSrc )     

{    

    //将源字符串加const，表明其为输入参数，加2分    

    while( (*strDest++ = * strSrc++) != '/0' );    

}     

 

//得7分    

void strcpy(char *strDest, const char *strSrc)     

{    

    //对源地址和目的地址加非0断言，加3分    

    assert( (strDest != NULL) && (strSrc != NULL) );    

    while( (*strDest++ = * strSrc++) != '/0' );    

}     

 

//得9分    

//为了实现链式操作，将目的地址返回，加2分！    

char * strcpy( char *strDest, const char *strSrc )     

{    

    assert( (strDest != NULL) && (strSrc != NULL) );    

    char *address = strDest;     

    while( (*strDest++ = * strSrc++) != '/0' );     

    return address;    

}   

 

//得10分，基本上所有的情况，都考虑到了 

//如果有考虑到源目所指区域有重叠的情况，加1分！    

char * strcpy( char *strDest, const char *strSrc )     

{    

    if(strDest == strSrc) { return strDest; } 

    assert( (strDest != NULL) && (strSrc != NULL) );    

    char *address = strDest;     

    while( (*strDest++ = * strSrc++) != '/0' );     

    return address;    

}   

 

 

第三节、小部分库函数的实现

    考察此类编写同库函数一样功能的函数经常见于大大小小的IT公司的面试题目中，以下是常见的字符串库函数的实现，希望，对你有所帮助，有任何问题，欢迎不吝指正：

 

//@yansha:字串末尾要加结束符'/0'，不然输出错位结果 

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);  

}  

  

//要处理src和dest有重叠的情况，不是从尾巴开始移动就没问题了。 

//一种情况是dest小于src有重叠，这个时候要从头开始移动， 

//另一种是dest大于src有重叠，这个时候要从尾开始移动。 

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;  

} 

        

  测试：以上所有的函数，都待进一步测试，有任何问题，欢迎任何人随时不吝指出。

 

第四节、c标准库部分源代码

    为了给各位一个可靠的参考，以下，我摘取一些c标准框里的源代码，以飨各位：

 

char * __cdecl strcat (char * dst,const char * src) 

{ 

    char * cp = dst; 

     

    while( *cp ) 

        cp++;                   /* find end of dst */ 

     

    while( *cp++ = *src++ ) ;       /* Copy src to end of dst */ 

     

    return( dst );                  /* return dst */ 

     

} 

 

int __cdecl strcmp (const char * src,const char * dst) 

{ 

    int ret = 0 ; 

     

    while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst) 

        ++src, ++dst; 

     

    if ( ret < 0 ) 

        ret = -1 ; 

    else if ( ret > 0 ) 

        ret = 1 ; 

     

    return( ret ); 

} 

 

size_t __cdecl strlen (const char * str) 

{ 

    const char *eos = str; 

     

    while( *eos++ ) ; 

     

    return( (int)(eos - str - 1) ); 

} 

 

char * __cdecl strncat (char * front,const char * back,size_t count) 

{ 

    char *start = front; 

     

    while (*front++) 

        ; 

    front--; 

     

    while (count--) 

        if (!(*front++ = *back++)) 

            return(start); 

         

        *front = '/0'; 

        return(start); 

} 

 

int __cdecl strncmp (const char * first,const char * last,size_t count) 

{ 

    if (!count) 

        return(0); 

     

    while (--count && *first && *first == *last) 

    { 

        first++; 

        last++; 

    } 

     

    return( *(unsigned char *)first - *(unsigned char *)last ); 

} 

 

/* Copy SRC to DEST.  */ 

char * 

strcpy (dest, src) 

char *dest; 

const char *src; 

{ 

    reg_char c; 

    char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src); 

    const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1; 

    size_t n; 

     

    do 

    { 

        c = *s++; 

        s[off] = c; 

    } 

    while (c != '/0'); 

     

    n = s - src; 

    (void) CHECK_BOUNDS_HIGH (src + n); 

    (void) CHECK_BOUNDS_HIGH (dest + n); 

     

    return dest; 

} 

 

char * __cdecl strncpy (char * dest,const char * source,size_t count) 

{ 

    char *start = dest; 

     

    while (count && (*dest++ = *source++))    /* copy string */ 

        count--; 

     

    if (count)                              /* pad out with zeroes */ 

        while (--count) 

            *dest++ = '/0';  

        

        return(start); 

} 

 

wangxfvc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python常见字符串处理函数与用法汇总
09-18
主要介绍了python常见字符串处理函数与用法,结合实例形式详细分析了Python字符串操作函数find、join、replace及split功能、使用技巧与操作注意事项,需要的朋友可以参考下
pandas 字符串处理方法介绍
zhusongziye的博客
11-23 4609
本文示例代码及文件已上传至Github仓库：https://github.com/CNFeffery/DataScienceStudyNotes 1 简介 在日常开展数据分析的过程中，我们经常需要对字符串类型数据进行处理，此类过程往往都比较繁琐，而pandas作为表格数据分析利器，其内置的基于Series.str访问器的诸多针对字符串进行处理的方法，以及一些top-level级的内置函数，则可以帮助我们大大提升字符串型数据处理的效率。 本文我就将带大家学习pandas中常用的一些高效字符串处理方法..
简单字符串处理
罗勇军的博客
03-29 8883
介绍C++、Java、Python的字符串处理函数。大量习题。
arduino字符串处理函数
weixin_52668204的博客
04-16 3364
判断字符串是否相等 equals()和equalsIgnoreCase() 语法 string.equals(string2) string.equalsIgnoreCase(string) 区别：是否忽略大小写 返回值布尔类型 将字符串复制到宁一个指定变量 getBytes() 语法 string.getBytes(buf,len) 参数 string：原来的字符串 buf：目的变量 len：字符串长度 字符串中寻找特定的字符串（往后找） indexOf() 语法 string.indexOf..
Python字符串处理
Bo_B0的博客
04-20 7885
1.字符串之find()方法查找 Python 提供了内置的字符串查找方法find()，利用该方法可以在一个较长的字符串中查找子字符串。如果该字符串中，有一个或者多个子字符串，则该方法返回第一个子串所在位置的最左端索引，若没有找到符合条件的子串，则返回-1。 find()方法的基本使用语法如下： source_string.find(sub_string) 其中： source_string：源字符串； sub_string：待查的目标子字符串； find：字符串查找方法的语法关键字。 例如，在一个字符
C语言使用字符串处理函数
最新发布
NuYoaH502329的博客
11-12 3286
如何使用字符串处理函数，字符串函数总结
Access字符串处理函数整理
09-11
在access数据库中用的到的一些字符串处理函数代码，需要的朋友可以参考下。
Ruby 字符串处理
01-21
Ruby将字符串像数字一样处理.我们用单引号(‘…’)或双引号(…)将它们括起来. ruby> abc  abc ruby> ‘abc’  abc 单引号和双引号在某些情况下有不同的作用.一个由双引号括起来的字符串允许字符由一个前置的斜杠...
字符串处理类
11-07
/// 是否包含字符串,可以直接. /// /// 字符串. /// 被查找的字符串. /// <returns></returns> public static bool Contains(string text, string patten) { //去掉收尾的扩展“%”字符 if (string....
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8702
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3097
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3545
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1445
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2152
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
HTML实现学习网站首页
做技术，坚持才是最重要的，一时的热情只是暂时的进步
02-20 3885
项目访问 reset.css /* http://meyerweb.com/eric/tools/css/reset/ v2.0 | 20110126 License: none (public domain) */ html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del
C语言经典小游戏之----推箱子
嵌入式技术开发
02-25 4558
在进行推箱子的实验中，可以使用对应的API函数来改变对应箱子的颜色，也需要根据，人在移动的过程中，可以通过方向键，并改变对应的颜色，从而实现控制人物的目的。 代码实现如下： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<windows.h> #include<conio.h> int x = 0, y = 0; //存储当前使用的...
关于Dubbo的mock=true降级无法调用降级类ServiceMock的解决方案
weixin_45754452的博客
02-25 1262
问题 消费者使用mock=“true”，想调用TestServiceMock进行服务降级无法调用 原因 我的项目结构如下，首先要知道服务降级代码应该是谁执行的，服务降级是服务消费者也就是controller包处对应的服务执行的，因为我只是测试dubbo怎么使用，所以并没有分多模块，但完全可以把一个包理解为一个模块，再看下面配置文件 为什么可以把一个包当成一个模块呢，因为我把配置文件的scan改成controller包然后启动一个服务器，即消费者，如果把scan改成service则可以启动服务提供者服务器
Vue---Vue基础
前端与计算机相关知识的分享，博主的qq523235674
02-25 1333
一.Vue概述 二.Vue的基本使用 2.1Vue.js之hello world 基本实例 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <title>Document</title> </.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值