C语言常见字符串面试题

最新推荐文章于 2024-07-30 18:10:16 发布
最新推荐文章于 2024-07-30 18:10:16 发布
阅读量598 收藏 4
点赞数 1
分类专栏： 数据结构

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

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)写出在母串中查找子串出现次数的代码.
[cpp]  view plain  copy
  1. int count1(char* str,char* s)  
  2. {  
  3.     char* s1;  
  4.     char* s2;  
  5.     int count = 0;  
  6.     while(*str!='/0')  
  7.     {  
  8.         s1 = str;  
  9.         s2 = s;  
  10.         while(*s2 == *s1&&(*s2!='/0')&&(*s1!='0'))  
  11.         {  
  12.             s2++;  
  13.             s1++;  
  14.         }  
  15.         if(*s2 == '/0')  
  16.             count++;  
  17.         str++;  
  18.     }  
  19.     return count;  
  20. }  
2）查找第一个匹配子串位置,如果返回的是s1长度len1表示没有找到
[cpp]  view plain  copy
  1. size_t find(char* s1,char* s2)  
  2.     {  
  3.         size_t i=0;  
  4.          size_t len1 = strlen(s1)  
  5.         size_t len2 = strlen(s2);  
  6.         if(len1-len2<0) return len1;  
  7.         for(;i<len1-len2;i++)  
  8.         {  
  9.             size_t m = i;  
  10.             for(size_t j=0;j<len2;j++)  
  11.             {  
  12.                 if(s1[m]!=s2[j])  
  13.                     break;  
  14.                 m++;  
  15.             }  
  16.             if(j==len)  
  17.                 break;  
  18.         }  
  19.         return i<len1-len2?i:len1;  
  20.     }  

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

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

[cpp]  view plain  copy
  1. ＃i nclude<stdio.h>  
  2. ＃i nclude<stdlib.h>  
  3. ＃i nclude<string.h>  
  4. char *commanstring(char shortstring[], char longstring[])  
  5. {  
  6.     int i, j;  
  7.     char *substring=malloc(256);  
  8.     if(strstr(longstring, shortstring)!=NULL)              //如果……，那么返回shortstring  
  9.         return shortstring;   
  10.     for(i=strlen(shortstring)-1;i>0; i--)                 //否则，开始循环计算  
  11.     {  
  12.         for(j=0; j<=strlen(shortstring)-i; j++)  
  13.         {  
  14.             memcpy(substring, &shortstring[j], i);  
  15.             substring[i]='/0';  
  16.             if(strstr(longstring, substring)!=NULL)  
  17.             return substring;  
  18.         }  
  19.     }  
  20.     return NULL;  
  21. }  
  22.   
  23. main()  
  24. {  
  25.     char *str1=malloc(256);  
  26.     char *str2=malloc(256);  
  27.     char *comman=NULL;  
  28.     gets(str1);  
  29.     gets(str2);  
  30.     if(strlen(str1)>strlen(str2))                         //将短的字符串放前面  
  31.         comman=commanstring(str2, str1);  
  32.     else  
  33.         comman=commanstring(str1, str2);  
  34.     printf("the longest comman string is: %s/n", comman);  
  35. }  

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

[cpp]  view plain  copy
  1. int IsReverseStr(char *str)  
  2. {  
  3.     int i,j;  
  4.     int found=1;  
  5.     if(str==NULL)  
  6.         return -1;  
  7.     char* p = str-1;  
  8.     while(*++p!= '/0');  
  9.     --p;  
  10.     while(*str==*p&&str<p) str++,p--;  
  11.     if(str < p)  
  12.         found = 0;  
  13.     return found;  
  14. }  

9)写函数完成内存的拷贝
[cpp]  view plain  copy
  1. void* memcpy( void *dst, const void *src, unsigned int len )  
  2. {  
  3.     register char *d;  
  4.     register char *s;  
  5.     if (len == 0)  
  6.         return dst;  
  7.     if ( dst > src )   //考虑覆盖情况  
  8.     {  
  9.         d = (char *)dst + len - 1;  
  10.         s = (char *)src + len - 1;  
  11.         while ( len >= 4 )   //循环展开，提高执行效率  
  12.         {  
  13.             *d-- = *s--;  
  14.             *d-- = *s--;  
  15.             *d-- = *s--;  
  16.             *d-- = *s--;  
  17.             len -= 4;  
  18.         }  
  19.         while ( len-- )   
  20.         {  
  21.             *d-- = *s--;  
  22.         }  
  23.     }   
  24.     else if ( dst < src )   
  25.     {  
  26.         d = (char *)dst;  
  27.         s = (char *)src;  
  28.         while ( len >= 4 )  
  29.         {  
  30.             *d++ = *s++;  
  31.             *d++ = *s++;  
  32.             *d++ = *s++;  
  33.             *d++ = *s++;  
  34.             len -= 4;  
  35.         }  
  36.         while ( len-- )  
  37.         {  
  38.             *d++ = *s++;  
  39.         }  
  40.     }  
  41.     return dst;  
  42. }  
出现次数相当频繁

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

[cpp]  view plain  copy
  1. int continumax(char *outputstr, char *inputstr)  
  2. {  
  3.     char *in = inputstr, *out = outputstr, *temp, *final;  
  4.     int count = 0, maxlen = 0;  
  5.     while( *in != '/0' )  
  6.     {  
  7.         if( *in > 47 && *in < 58 )  
  8.         {  
  9.             for(temp = in; *in > 47 && *in < 58 ; in++ )  
  10.             count++;  
  11.         }  
  12.     else  
  13.     in++;  
  14.     if( maxlen < count )  
  15.     {  
  16.         maxlen = count;  
  17.         count = 0;  
  18.         final = temp;  
  19.     }  
  20.     }  
  21.     for(int i = 0; i < maxlen; i++)  
  22.     {  
  23.         *out = *final;  
  24.         out++;  
  25.         final++;  
  26.     }  
  27.     *out = '/0';  
  28.     return maxlen;  
  29. }  

11) 编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
[cpp]  view plain  copy
  1. char * search(char *cpSource, char ch)  
  2. {  
  3.          char *cpTemp=NULL, *cpDest=NULL;  
  4.          int iTemp, iCount=0;  
  5.          while(*cpSource)  
  6.          {  
  7.                  if(*cpSource == ch)  
  8.                  {  
  9.                           iTemp = 0;  
  10.                           cpTemp = cpSource;  
  11.                           while(*cpSource == ch)   
  12.                                    ++iTemp, ++cpSource;  
  13.                           if(iTemp > iCount)   
  14.                                 iCount = iTemp, cpDest = cpTemp;  
  15.                         if(!*cpSource)   
  16.                             break;  
  17.                  }  
  18.                  ++cpSource;  
  19.      }  
  20.      return cpDest;  
  21. }        
排序算法:

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

[cpp]  view plain  copy
  1. void buble(int *a,int n)  
  2. {  
  3.     for(int i=0;i<n;i++)  
  4.     {  
  5.         for(int j=1;j<n-i;j++)  
  6.         {  
  7.             if(a[j]<a[j-1])  
  8.             {  
  9.                 int temp=a[j];  
  10.                 a[j] = a[j-1];  
  11.                 a[j-1] = temp;  
  12.             }  
  13.         }  
  14.     }  
  15. }  

插入排序：
[cpp]  view plain  copy
  1. void insertsort(int* a,int n)  
  2. {  
  3.     int key;  
  4.     for(int j=1;j<n;j++)  
  5.     {  
  6.         key = a[j];  
  7.         for(int i=j-1;i>=0&&a[i]>key;i--)  
  8.         {  
  9.             a[i+1] = a[i];  
  10.         }  
  11.         a[i+1] = key;  
  12.     }  
  13. }  

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

[cpp]  view plain  copy
  1. int atoii(char* s)  
  2. {  
  3.     assert(s!=NULL);  
  4.     int num = 0;  
  5.     int temp;  
  6.     while(*s>'0' && *s<'9')  
  7.     {  
  8.         num *= 10;  
  9.         num += *s-'0';  
  10.         s++;  
  11.     }  
  12.     return num;  
  13. }  
风中舵手
关注
专栏目录
C语言字符串类面试题汇总
m0_63089658的博客
09-14 552
【代码】C语言字符串类面试题汇总。
C语言面试题（字符和字符串处理）
D卡戎的博客
03-12 882
C语言面试必备，字符串处理相关面试题
C语言字符串面试题目总结
syouya.shiraki's blog
08-17 2569
1.面试常问道的 字符串拷贝函数的编写 /******************************************** *实现字符串的拷贝工作 *返回值用来实现链式操作 *如 strlen(strcpy(str, "fsdfsdf")); ********************************************/ char *strcpy(char *dest
C语言字符串练习（习题+答案）.zip
05-09
本资源"《C语言字符串练习（习题+答案）.zip》"正是针对这一需求而准备的，它包含了C语言字符串操作的专项练习题和对应的答案，帮助学习者巩固和提升在字符串处理方面的技能。 字符串在C语言中扮演着重要角色，它们...
C语言实现字符串面试题：strcpy、strcmp、转化与拷贝
"这篇资料主要涉及的是C语言中与字符串处理相关的面试题，包括字符串拷贝、比较、反转、整数与字符串之间的转换以及自定义的strcpy和memcpy函数。" 在C语言中，字符串处理是一门重要的技术，尤其是在面试中常常会...
c语言面试题之哈希表字符串中的第一个唯一字符.zip
03-29
在C语言面试中，哈希表（Hash Table）和字符串操作是常见的考察点。这个问题——“字符串中的第一个唯一字符”——旨在测试应聘者的数据结构理解、字符串处理以及算法设计能力。接下来，我们将深入探讨这个面试题所...
C面试题-字符串
一念流转
04-24 258
仅作为作者本人学习记录，读者需要一定的基础知识才能入手。
C语言面试题之字符串操作
sum_TW的博客
02-19 3969
今天做了花了几分钟做了三道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 434
关注、星标公众号，直达精彩内容来源：网络素材整理：李肖遥字符串倒序输出实现逻辑，通过strlen获取字符串长度，然后通过 len/2 进行交叉赋值，这里需要注意，不需要考虑len是奇数还是...
C语言面试题分类->字符串处理
weixin_30770783的博客
04-19 386
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 3325
在C语言中，将字符串作为字符数组来处理。C语言规定了一个“字符串结束标志”，以字符‘\0’代表。也就是说，在遇到第一个‘\0’字符时，表示字符串结束，由它前面的字符组成字符串。 一、字符数组 用字符串常量来初始化字符数组，例如： /* 例1 */ char str[] = {"I am happy"}; //也可以省略花括号 char str[] = "I am h...
100条经典C语言笔试题目
热门推荐
苦行僧
10-10 5万+
100 条经典C语言笔试题目 题目来源： 1、中兴、华为、慧通、英华达、微软亚洲技术中心等中 外企业面试题目； 2、C 语言面试宝典(林锐《高质量编程第三版》)。 说明： 1、部分C 语言面试题中可能会参杂部分和C++ 相关的知 识，为了保持题目的灵活性故保留，但选题最终还是 会以C 语言题目为主体； 2、以上公司的面试题目已成为国内中小型企业公司出题 模板； 3
C语言字符串练习例题及答案
s44Sc21的博客
05-12 1537
C语言字符串练习例题及答案
C语言 ——— 字符指针和常量字符串的笔试题和解析
最新发布
weixin_55341642的博客
07-30 359
p[0] + 1 表示的是取出第一个元素的首地址后加1，加1后指向的是第二个元素的首地址，那么strlen函数就会从第二个元素开始往后统计字符串元素个数。p 是指向第一个元素的地址，那么对 p 解引用，就找到了第一个元素，每个元素的大小是 char 类型的，那么 sizeof(char) = 1字节。p 是一维指针，对p取地址，那么 &p 就是二级指针，指向的是 p的地址，只要是地址。*p 表示的是第一个元素，第一个元素传递给strlen函数，参数不匹配。p[0] 表示的是第一个元素，所以。
C语言面试题100
jinqg的博客
05-11 1万+
1.请填写bool , float, 指针变量 与“零值”比较的if语句。 提示：这里“零值”可以是0, 0.0 , FALSE 或者“空指针”。 例如int 变量 n 与“零值”比较的 if 语句为： if ( n ==0 ) if ( n != 0 ) 以此类推。 bool: if(flag) if(!flag) float: const fl...
2016 C语言面试题——字符串函数的实现
AnSwEr不是答案
08-15 2907
C语言各类字符串函数的实现开学就要开始找工作了，我觉得这些函数被问到的几率还是很大的，所以在这里与大家分享strlen函数原型：#include <string.h> unsigned int strlen (char *s);功能：计算指定的字符串s 的长度，不包括结束字符”\0”。我的实现：/****************************************************
C、C++面试题：编程实现字符串中字串的查找
好儿郎~志在四方
03-15 4028
C、C++面试题：编程实现字符串中字串的查找详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值