C语言常见字符串面试题

最新推荐文章于 2024-06-12 11:16:03 发布
最新推荐文章于 2024-06-12 11:16:03 发布
阅读量1.7w 收藏 75
点赞数 5
分类专栏： linux c语言 面试 文章标签： 求职 面试 c 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hkh5730/article/details/14674183
版权

 一些常用字符串操作函数的内部实现 

memset:
  1. /*
  2.  * memset - Fill a region of memory with the given value
  3.  * @s: Pointer to the start of the area.
  4.  * @c: The byte to fill the area with
  5.  * @count: The size of the area.
  6.  */
  7. void *memset(void *s, int c, size_t count)
  8. {
  9.     char *xs = s;

  11.     while (count--)
  12.         *xs++ = c;
  13.     return s;
  14. }

memcpy:
  1. /*
  2. * memcpy - Copy one area of memory to another
  3. * @dest: Where to copy to
  4. * @src: Where to copy from
  5. * @count: The size of the area.
  6. */
  7. void *memcpy(void *dest, const void *src, size_t count)
  8. {
  9. char *tmp = dest;
  10. const char *s = src;
  12. while (count--)
  13. *tmp++ = *s++;
  14. return dest;
  15. }

memmove:
  1. /*
  2.  * memmove - Copy one area of memory to another
  3.  * @dest: Where to copy to
  4.  * @src: Where to copy from
  5.  * @count: The size of the area.
  6.  * Unlike memcpy(), memmove() copes with overlapping areas.
  7.  */
  8. void *memmove(void *dest, const void *src, size_t count)
  9. {
  10.     char *tmp;
  11.     const char *s;

  13.     if (dest <= src) {
  14.         tmp = dest;
  15.         s = src;
  16.         while (count--)
  17.             *tmp++ = *s++;
  18.     } else {
  19.         tmp = dest;
  20.         tmp += count;
  21.         s = src;
  22.         s += count;
  23.         while (count--)
  24.             *--tmp = *--s;
  25.     }
  26.     return dest;
  27. }

memcmp:
  1. /*
  2.  * memcmp - Compare two areas of memory
  3.  * @cs: One area of memory
  4.  * @ct: Another area of memory
  5.  * @count: The size of the area.
  6.  */
  7. int memcmp(const void *cs, const void *ct, size_t count)
  8. {
  9.     const unsigned char *su1, *su2;
  10.     int res = 0;

  12.     for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
  13.         if ((res = *su1 - *su2) != 0)
  14.             break;
  15.     return res;
  16. }

strcpy:
  1. /*
  2.  * strcpy - Copy a %NUL terminated string
  3.  * @dest: Where to copy the string to
  4.  * @src: Where to copy the string from
  5.  */
  6. char *strcpy(char *dest, const char *src)
  7. {
  8.     char *tmp = dest;

  10.     while ((*dest++ = *src++) != '\0');

  12.     return tmp;
  13. }

strncpy:
  1. /*
  2.  * strncpy - Copy a length-limited, %NUL-terminated string
  3.  * @dest: Where to copy the string to
  4.  * @src: Where to copy the string from
  5.  * @count: The maximum number of bytes to copy
  6.  *
  7.  * The result is not %NUL-terminated if the source exceeds
  8.  * @count bytes.
  9.  *
  10.  * In the case where the length of @src is less than that of
  11.  * count, the remainder of @dest will be padded with %NUL.
  12.  */
  13. char *strncpy(char *dest, const char *src, size_t count)
  14. {
  15.     char *tmp = dest;

  17.     while (count) {
  18.         if ((*tmp = *src) != 0)
  19.             src++;
  20.         tmp++;
  21.         count--;
  22.     }

  24.     return dest;
  25. }

strcat:
  1. /*
  2.  * strcat - Append one %NUL-terminated string to another
  3.  * @dest: The string to be appended to
  4.  * @src: The string to append to it
  5.  */
  6. char *strcat(char *dest, const char *src)
  7. {
  8.     char *tmp = dest;

  10.     while (*dest)
  11.         dest++;
  12.     while ((*dest++ = *src++) != '\0');

  14.     return tmp;
  15. }

strncat:
  1. /*
  2.  * strncat - Append a length-limited, %NUL-terminated string to another
  3.  * @dest: The string to be appended to
  4.  * @src: The string to append to it
  5.  * @count: The maximum numbers of bytes to copy
  6.  *
  7.  * Note that in contrast to strncpy(), strncat() ensures the result is
  8.  * terminated.
  9.  */
  10. char *strncat(char *dest, const char *src, size_t count)
  11. {
  12.     char *tmp = dest;

  14.     if (count) {
  15.         while (*dest)
  16.             dest++;
  17.         while ((*dest++ = *src++) != 0) {
  18.             if (--count == 0) {
  19.                 *dest = '\0';
  20.                 break;
  21.             }
  22.         }
  23.     }

  25.     return tmp;
  26. }

strcmp:
  1. /*
  2.  * strcmp - Compare two strings
  3.  * @cs: One string
  4.  * @ct: Another string
  5.  */
  6. int strcmp(const char *cs, const char *ct)
  7. {
  8.     unsigned char c1, c2;

  10.     while (1) {
  11.         c1 = *cs++;
  12.         c2 = *ct++;
  13.         if (c1 != c2)
  14.             return c1 < c2 ? -1 : 1;
  15.         if (!c1)
  16.             break;
  17.     }

  19.     return 0;
  20. }

strncmp:
  1. /*
  2.  * strncmp - Compare two length-limited strings
  3.  * @cs: One string
  4.  * @ct: Another string
  5.  * @count: The maximum number of bytes to compare
  6.  */
  7. int strncmp(const char *cs, const char *ct, size_t count)
  8. {
  9.     unsigned char c1, c2;

  11.     while (count) {
  12.         c1 = *cs++;
  13.         c2 = *ct++;
  14.         if (c1 != c2)
  15.             return c1 < c2 ? -1 : 1;
  16.         if (!c1)
  17.             break;
  18.         count--;
  19.     }

  21.     return 0;
  22. }

strchr:
  1. /*
  2.  * strchr - Find the first occurrence of a character in a string
  3.  * @s: The string to be searched
  4.  * @c: The character to search for
  5.  */
  6. char *strchr(const char *s, int c)
  7. {
  8.     for (; *s != (char)c; ++s)
  9.         if (*s == '\0')
  10.             return NULL;

  12.     return (char *)s;
  13. }

strlen:
  1. /*
  2.  * strlen - Find the length of a string
  3.  * @s: The string to be sized
  4.  */
  5. size_t strlen(const char *s)
  6. {
  7.     const char *sc;

  9.     for (sc = s; *sc != '\0'; ++sc);

  11.     return sc - s;
  12. }

strnlen:
  1. /*
  2.  * strnlen - Find the length of a length-limited string
  3.  * @s: The string to be sized
  4.  * @count: The maximum number of bytes to search
  5.  */
  6. size_t strnlen(const char *s, size_t count)
  7. {
  8.     const char *sc;

  10.     for (sc = s; count-- && *sc != '\0'; ++sc);

  12.     return sc - s;
  13. }

strsep:
  1. /*
  2.  * strsep - Split a string into tokens
  3.  * @s: The string to be searched
  4.  * @ct: The characters to search for
  5.  *
  6.  * strsep() updates @s to point after the token, ready for the next call.
  7.  */
  8. char *strsep(char **s, const char *ct)
  9. {
  10.     char *sbegin = *s;
  11.     char *end;

  13.     if (sbegin == NULL)
  14.         return NULL;

  16.     end = strpbrk(sbegin, ct);
  17.     if (end)
  18.         *end++ = '\0';
  19.     *s = end;

  21.     return sbegin;
  22. }

strstr:
  1. /*
  2.  * strstr - Find the first substring in a %NUL terminated string
  3.  * @s1: The string to be searched
  4.  * @s2: The string to search for
  5.  */
  6. char *strstr(const char *s1, const char *s2)
  7. {
  8.     int l1, l2;

  10.     l2 = strlen(s2);
  11.     if (!l2)
  12.         return (char *)s1;
  13.     l1 = strlen(s1);
  14.     while (l1 >= l2) {
  15.         l1--;
  16.         if (!memcmp(s1, s2, l2))
  17.             return (char *)s1;
  18.         s1++;
  19.     }

  21.     return NULL;
  22. }
常见字符串面试题：
1)写出在母串中查找子串出现次数的代码. 
int count1(char* str,char* s)
{
    char* s1;
    char* s2;
    int count = 0;
    while(*str!='/0')
    {
        s1 = str;
        s2 = s;
        while(*s2 == *s1&&(*s2!='/0')&&(*s1!='0'))
        {
            s2++;
            s1++;
        }
        if(*s2 == '/0')
            count++;
        str++;
    }
    return count;
}
2）查找第一个匹配子串位置,如果返回的是s1长度len1表示没有找到 
size_t find(char* s1,char* s2)
    {
        size_t i=0;
         size_t len1 = strlen(s1)
        size_t len2 = strlen(s2);
        if(len1-len2<0) return len1;
        for(;i<len1-len2;i++)
        {
            size_t m = i;
            for(size_t j=0;j<len2;j++)
            {
                if(s1[m]!=s2[j])
                    break;
                m++;
            }
            if(j==len)
                break;
        }
        return i<len1-len2?i:len1;
    }

3)实现strcpy函数 
char *strcpy(char *destination, const char *source) 
{ 
    assert(destination!=NULL&&source!=NULL);
    char* target = destinaton;
    while(*destinaton++=*source++); 
    return target ; 
}
出现次数相当频繁
4)实现strcmp函数 
int strcmp11(char* l,char* r)
{
    assert(l!=0&&r!=0);
    while(*l == *r &&*l != '/0') l++,r++;
    if(*l > *r)
        return 1;
    else if(*l == *r)
        return 0;
    return -1;
}
5) 实现字符串翻转 
void reserve(char* str)
{
    assert(str != NULL);
    char * p1 = str;
    char * p2 = str-1;
    while(*++p2);         //一般要求不能使用strlen
    p2 -= 1;
    while(p1<p2)
    {
        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
   }
}
6）、用指针的方法，将字符串“ABCD1234efgh”前后对调显示
//不要用strlen求字符串长度，这样就没分了
代码如下:
     
char str123[] = "ABCD1234efgh";
    char * p1 = str123;
    char * p2 = str123-1;
    while(*++p2);
    p2 -= 1;
    while(p1<p2)
    {
        char c = *p1;
        *p1++ = *p2;
        *p2-- = c;
    }

7) 给定字符串A和B,输出A和B中的最大公共子串。比如A="aocdfe" B="pmcdfa" 则输出"cdf"

＃i nclude<stdio.h>
＃i nclude<stdlib.h>
＃i nclude<string.h>
char *commanstring(char shortstring[], char longstring[])
{
    int i, j;
    char *substring=malloc(256);
    if(strstr(longstring, shortstring)!=NULL)              //如果……，那么返回shortstring
        return shortstring; 
    for(i=strlen(shortstring)-1;i>0; i--)                 //否则，开始循环计算
    {
        for(j=0; j<=strlen(shortstring)-i; j++)
        {
            memcpy(substring, &shortstring[j], i);
            substring[i]='/0';
            if(strstr(longstring, substring)!=NULL)
            return substring;
        }
    }
    return NULL;
}

main()
{
    char *str1=malloc(256);
    char *str2=malloc(256);
    char *comman=NULL;
    gets(str1);
    gets(str2);
    if(strlen(str1)>strlen(str2))                         //将短的字符串放前面
        comman=commanstring(str2, str1);
    else
        comman=commanstring(str1, str2);
    printf("the longest comman string is: %s/n", comman);
}

8) 判断一个字符串是不是回文

int IsReverseStr(char *str)
{
    int i,j;
    int found=1;
    if(str==NULL)
        return -1;
    char* p = str-1;
    while(*++p!= '/0');
    --p;
    while(*str==*p&&str<p) str++,p--;
    if(str < p)
        found = 0;
    return found;
}

9)写函数完成内存的拷贝 
void* memcpy( void *dst, const void *src, unsigned int len )
{
    register char *d;
    register char *s;
    if (len == 0)
        return dst;
    if ( dst > src )   //考虑覆盖情况
    {
        d = (char *)dst + len - 1;
        s = (char *)src + len - 1;
        while ( len >= 4 )   //循环展开，提高执行效率
        {
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            *d-- = *s--;
            len -= 4;
        }
        while ( len-- ) 
        {
            *d-- = *s--;
        }
    } 
    else if ( dst < src ) 
    {
        d = (char *)dst;
        s = (char *)src;
        while ( len >= 4 )
        {
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            *d++ = *s++;
            len -= 4;
        }
        while ( len-- )
        {
            *d++ = *s++;
        }
    }
    return dst;
}
出现次数相当频繁

10）写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)
功能：
在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如："abcd12345ed125ss123456789"的首地址传给intputstr后，函数将返回9，outputstr所指的值为123456789

int continumax(char *outputstr, char *inputstr)
{
    char *in = inputstr, *out = outputstr, *temp, *final;
    int count = 0, maxlen = 0;
    while( *in != '/0' )
    {
        if( *in > 47 && *in < 58 )
        {
            for(temp = in; *in > 47 && *in < 58 ; in++ )
            count++;
        }
    else
    in++;
    if( maxlen < count )
    {
        maxlen = count;
        count = 0;
        final = temp;
    }
    }
    for(int i = 0; i < maxlen; i++)
    {
        *out = *final;
        out++;
        final++;
    }
    *out = '/0';
    return maxlen;
}

11) 编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
 
char * search(char *cpSource, char ch)
{
         char *cpTemp=NULL, *cpDest=NULL;
         int iTemp, iCount=0;
         while(*cpSource)
         {
                 if(*cpSource == ch)
                 {
                          iTemp = 0;
                          cpTemp = cpSource;
                          while(*cpSource == ch) 
                                   ++iTemp, ++cpSource;
                          if(iTemp > iCount) 
                                iCount = iTemp, cpDest = cpTemp;
                        if(!*cpSource) 
                            break;
                 }
                 ++cpSource;
     }
     return cpDest;
}
排序算法:

冒泡排序: 出现次数相当频繁

void buble(int *a,int n)
{
    for(int i=0;i<n;i++)
    {
        for(int j=1;j<n-i;j++)
        {
            if(a[j]<a[j-1])
            {
                int temp=a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

插入排序： 
void insertsort(int* a,int n)
{
    int key;
    for(int j=1;j<n;j++)
    {
        key = a[j];
        for(int i=j-1;i>=0&&a[i]>key;i--)
        {
            a[i+1] = a[i];
        }
        a[i+1] = key;
    }
}

将一个数字字符串转换为数字."1234" -->1234

int atoii(char* s)
{
    assert(s!=NULL);
    int num = 0;
    int temp;
    while(*s>'0' && *s<'9')
    {
        num *= 10;
        num += *s-'0';
        s++;
    }
    return num;
}



hkh5730
关注
  • 5
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言字符串类面试题汇总
m0_63089658的博客
09-14 512
【代码】C语言字符串类面试题汇总。
C语言字符串练习（习题+答案）.zip
05-09
本资源"《C语言字符串练习（习题+答案）.zip》"正是针对这一需求而准备的，它包含了C语言字符串操作的专项练习题和对应的答案，帮助学习者巩固和提升在字符串处理方面的技能。 字符串在C语言中扮演着重要角色，它们...
C语言面试题总结（含参考答案）------持续更新
最新发布
嵌入式领域、软硬件开发
06-12 3208
变量的声明是指在程序中告诉编译器有一个变量存在，并且指定该变量的类型，但并没有为该变量分配内存空间。而变量的定义是指在程序中为变量分配了内存空间，同时也进行了初始化。
C语言字符串面试题目总结
syouya.shiraki's blog
08-17 2552
1.面试常问道的 字符串拷贝函数的编写 /******************************************** *实现字符串的拷贝工作 *返回值用来实现链式操作 *如 strlen(strcpy(str, "fsdfsdf")); ********************************************/ char *strcpy(char *dest
C语言面试题（字符和字符串处理）
D卡戎的博客
03-12 830
C语言面试必备，字符串处理相关面试题
C面试题-字符串
一念流转
04-24 241
仅作为作者本人学习记录，读者需要一定的基础知识才能入手。
c语言面试题之哈希表字符串中的第一个唯一字符.zip
03-29
在C语言面试中，哈希表（Hash Table）和字符串操作是常见的考察点。这个问题——“字符串中的第一个唯一字符”——旨在测试应聘者的数据结构理解、字符串处理以及算法设计能力。接下来，我们将深入探讨这个面试题所...
c语言面试题之双指针反转字符串.zip
03-29
在这个"反转字符串"的面试题中，我们将深入探讨如何使用双指针来实现这一任务。 首先，我们需要了解C语言中字符串的基本概念。在C语言中，字符串是由零个或多个字符组成的序列，以空字符'\0'作为结束标志。我们通常...
C语言基础面试题（03-字符串函数）.docx
11-21
以上解答了C语言中涉及字符串处理的一些基础面试题，实际编程中，我们需要考虑到边界条件、效率优化和错误处理等因素，确保代码的健壮性和正确性。在面试中，理解这些基本概念并能灵活运用是至关重要的。
字符串面试题整理
08-19
字符串是编程语言中常见且重要的数据结构之一，尤其在面试中常常被用来考察候选人的逻辑思维和算法理解能力。以下是一些与字符串相关的面试题目及其解题思路： 1. **字符串循环左移**：给定一个字符串和一个整数k，...
一些有关字符串 的常考面试题
01-11
一些与字符串有关的常考的面试题，用C语言实现的
C语言面试题之字符串操作
sum_TW的博客
02-19 3950
今天做了花了几分钟做了三道C语言面试题，跟大家分享一下： 找错 Void test1() { char string[10]; char* str1="0123456789"; strcpy(string, str1); } 答：string 大小不够 str1末尾还有一个'\0' Void test2() { char string[10], str1[10];
这些常见的C语言字符串操作面试题，被问到了吗？
李肖遥的专栏
03-13 422
关注、星标公众号，直达精彩内容来源：网络素材整理：李肖遥字符串倒序输出实现逻辑，通过strlen获取字符串长度，然后通过 len/2 进行交叉赋值，这里需要注意，不需要考虑len是奇数还是...
C语言面试题分类->字符串处理
weixin_30770783的博客
04-19 373
1.strlen：计算字符串长度（不包含'\0'）实现想法：遍历字符串，直到'\0'结束 #include<stdio.h> #include<stdlib.h> #include<string.h> //指针法 unsigned int mystrlenaddr(const char * str) //为什么使用const char，我们...
经典C语言面试题12：C语言字符串与字符数组
M_joy666的博客
08-10 3291
在C语言中，将字符串作为字符数组来处理。C语言规定了一个“字符串结束标志”，以字符‘\0’代表。也就是说，在遇到第一个‘\0’字符时，表示字符串结束，由它前面的字符组成字符串。 一、字符数组 用字符串常量来初始化字符数组，例如： /* 例1 */ char str[] = {"I am happy"}; //也可以省略花括号 char str[] = "I am h...
C/C++ | 30-25 在一个字符串中找到可能的最长的子字符串
qq_38362761的博客
07-28 1353
编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。 #include #include #include #include #include #include #include #include #include using namespace std; void FindMaxLong(char *s,ch
请编写一个C函数，该函数在一个字符串中找到可能的最长的字符串，该字符串是由同一个字符组成的。
今天比昨天进步一点点
09-07 4175
int ChildString(char* p) { char *q=p; int stringlen=0,len=0,maxlen=0; while(*q!='\0') { stringlen++; q++; } int i=0; int j=0; while(i&lt;stringlen) ...
C语言下的lmi函数,C语言笔试题
weixin_30725829的博客
05-20 1338
C语言笔试题1.请填写bool , float, 指针变量 与“零值”比较的if语句。bool i;flaot j;char *p;if(i);const float ESPINON=0.00001;if(j>-ESPINON&&jif(p==NULL);2.以下为Linux下的32 位C 程序，请计算sizeof 的值。char str[]="hello";char *p...
C语言面试题解析：字符串与数组的陷阱
"这篇文档是关于C语言面试题的解析，主要涵盖了字符串处理和循环控制等基础知识，通过分析几个常见的编程错误来考察面试者对C语言的理解。" 在这份文档中，作者重解了几道华为等大厂的经典C语言面试题，主要关注的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值