004字符串操作strstr，strcpy等

最新推荐文章于 2022-09-19 20:23:30 发布
最新推荐文章于 2022-09-19 20:23:30 发布
阅读量455 收藏
点赞数
分类专栏： 算法知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongqing0812/article/details/32715367
版权

第一节、字符串查找
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;    
    int i,j;  
    for (i = 0; i <= len; i++)   //复杂度为O(m*n)       
    {       
        for (j = 0; j < lensub; j++)       
        {       
            if (string[i+j] != substring[j])       
                break;       
        }       
        if (j == lensub)       
            return i + 1;       
    }       
    return -1;       
}

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';  //没有找到满足条件的字符，退出       
}

位图法 

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 ;    
        }    
    }    
}
第二节、字符串拷贝
题目描述：
要求实现库函数strcpy，
原型声明：extern char *strcpy(char *dest,char *src); 
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。 　
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 　
返回指向dest的指针。 

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



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

1

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

2 

//查找字符串s中首次出现字符c的位置     
char *strchr(const char *str, int c)     
{     
    assert(str != NULL);     
    for (; *str != (char)c; ++ str)     
        if (*str == '\0')     
            return NULL;     
        return str;     
}

3 

int strcmp(const char *s, const char *t)     
{     
    assert(s != NULL && t != NULL);     
    while (*s && *t && *s == *t)     
    {     
        ++ s;     
        ++ t;     
    }     
    return (*s - *t);     
}

4 

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

5 

int strlen(const char *str)     
{     
    assert(str != NULL);     
    int len = 0;     
    while (*str ++ != '\0')     
        ++ len;     
    return len;     
}
6 

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

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

8 

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

9 

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

10 
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;     
}

11 

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;     
}
12 

char *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;    
}    
  
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);     
}     
  
//@big：    
//要处理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;     
}









keepgulp
关注
专栏目录
strcpy拷贝字符串、strcat追加字符串、strcmp比较字符串、查找子字符串 strstr、切割字符串strtok
DAFENGZI123_的博客
09-04 423
字符函数和字符串函数1.strcpy拷贝字符串2.strcat追加字符串3.strcmp比较字符串4.查找子字符串 strstr5.切割字符串strtok 1.strcpy拷贝字符串 char* strcpy(char * destination, const char * source ); —源字符串必须以 ‘\0’ 结束。 —会将源字符串中的 ‘\0’ 拷贝到目标空间。 —目标空间必须足够大，以确保能存放源字符串。 —目标空间必须可变。 //--------------------strcpy、字符
c语言strcpy两字符串长度不同,（C语言）自己写字符串操作函数(一)——strlen/strcpy/strcat/strcmp/st...
weixin_39888807的博客
05-17 1006
看到很多面试都会要求你写一些简单的字符串操作函数，这些函数看起来挺简单的，但是自己写的时候就会发现不少的问题。所以我自己把大部分的字符串操作函数都写了一遍，然后用了个测试程序来测试自己写的函数与库函数是否相同。包括字符串长度函数、不受限制的字符串函数、受限制的字符串函数、字符串查找基础函数。下面直接上代码：my_string.h 字符串操作函数头文件#include #define NUL '\0...
strstr和strcpy函数实现
08-02
strstr函数和strcpy函数的简单实现
strstr，strcpy，strcat
SirL001的博客
11-29 887
均在string下 strcpy(s1,s2): 将s2的字符串复制到s1中，不影响s2。若s2字符串短于s1，则新的s1包括s2及旧的s1的后半部分。 strcat(s1,s2): 将s2的字符串连接到s1末尾，不影响s2。 strstr(s1,s2): #include <stdio.h> #include <string.h> int main(){ char s1[10]="hello,"; char s2[10]="world."; cha...
strcpy函数 和 strstr函数
coolwriter的博客
06-03 513
大家一般认为名不见经传strcpy函数实现不是很难，流行的strcpy函数写法是：   char *my_strcpy(char *dst,const char *src) { assert(dst != NULL); assert(src != NULL); char *ret = dst; while((* dst++ = * src+...
strstr() 、strcpy() 、strcat()、 strcmp() 和其他相关函数以及一些问题的出现
QQ845264718
03-31 392
strstr() 函数原型： char*strstr(char*const str1, const char*const str2); 功能： 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回 str1字符串从 str2第一次出现的位置开始到 str1结尾的字符串；否则，返回NULL 例子： #include <iostream> #include <string.h> using namespace std; int main() { cha
strcmp，strcpy，strstr函数
yj
11-11 751
strcmp（）函数 strcmp()函数用来比较两个字符串的大小 strcmp(字符串1，字符串2) 如果字符串1==字符串2，则函数值为0； 如果字符串1>字符串2，则函数值为一个正整数； 如果字符串1<字符串2，则函数值为一个负整数； char src[10] = "hellocd"; char tar[10] = "helloc"; char bar[10] = "hell"; int x = strcmp(src, tar); i
C语言字符串操作总结大全(超详细)
01-01
1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略...
c语言基础-c语言编程基础之字符串操作-查找常用字符串.zip
最新发布
03-17
- 在文本处理中，字符串操作广泛用于读取、解析和输出信息，如日志文件分析、命令行参数处理等。 - 在软件开发中，字符串处理是用户界面和数据交换的关键部分，如文件路径处理、URL解析等。 - 在网络编程中，TCP/...
单片机c语言字符串操作
08-10
首先，`strcpy()` 函数用于完全复制一个字符串，例如 `strcpy(chardes, charsoure)` 会将 `charsoure` 中的字符串完全复制到 `chardes`。而 `strncpy()` 则更灵活，它允许你指定要复制的字符数量。如 `strncpy...
常见字符串函数实现strstr，strcpy，strlen，strcat，strcmp
ChaseHeart的博客
06-27 250
常见字符串函数实现 1、strstr strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串（hello,ll----->2) KMP算法---->字符串单模匹配的模型 void getNext(int* next, const string& s) { int j = 0; next[0] = 0; for(int i = 1; i < s.size(); i++) {
【LeetCode】10.实现strStr()
qq_40314507的博客
01-09 175
0.题目描述 实现 strStr() 函数。 给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。 1.题目分析 首先我们来看平凡的情况。我这里分以下几个情况： （1）haystack为空，needle不为空。处理：返回-1。 （2）haystack为...
C语言字符串操作大全
良师，益友
12-08 1万+
附：转载他人，自己加工。   1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略大小写比较字符串 strncm
C++ string类字符串处理
luguoshan的博客
05-07 1404
转载http://c.biancheng.net/view/400.html 1. 构造函数 string 类有多个构造函数，用法示例如下： string s1(); // si = "" string s2("Hello"); // s2 = "Hello" string s3(4, 'K'); // s3 = "KKKK" string s4("12345", 1, 3)...
字符串操作函数strstr
热门推荐
weixin_61486281的博客
09-19 3万+
在编写程序的过程中，我们不可避免地会调用字符串操作函数，今天要介绍的字符串操作函数是strstr函数。strstr函数是在字符串str1中查找是否含有字符串str2，如果存在，返回str2在str1中第一次出现的地址；否则返回NULL。//strstr函数的应用int main(){return 0;}
解题思路-leetcode第二十八题：实现 strStr()
PPlemoin123的博客
04-17 193
解题思路-leetcode第二十八题：实现 strStr() 题目描述： 实现 strStr() 函数。 给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。 示例 1: 输入: haystack = “hello”, needle = “ll” 输出: 2 示例 2: ...
LeetCode算法日记：数组和字符串
happykoi的博客
07-12 274
123
C/C++ 刷题中头疼的字符串
qq_43142509的博客
10-30 320
前言 字符串可以看成是字符组成的数组。由于字符串是程序里经常需要处理的数据类型，因此有很多针对字符串处理的题目，以下是一些常见的类型。 344.反转字符串 题目描述 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 输入输出样例 输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"] 题解 这里其实可以用库 reverse
C语言字符串操作：strcpy与memcpy的区别
- `strstr()`：在字符串中查找子字符串首次出现的位置。 在编程实践中，熟练掌握这些函数能显著提高代码效率和可读性。例如，`strchr()` 可用于查找特定字符，`strtok()` 可以用来分隔字符串，而 `sprintf()` 或 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值