C语言字符串笔试题含答案

目录

面试题1：使用库函数将数字转换为字符串  出现频率：***

面试题2：不使用库函数将整数转换成字符串  出现频率：*****

面试题3：使用库函数将字符串转换为数字  出现频率：****

面试题4：不使用库函数将字符串转换为数字  出现频率：****

面试题5：编程实现strcpy函数  出现频率：****

面试题6：编程实现memcpy函数  出现频率：****

面试题7：strcpy与memcpy的区别  出现频率：****

面试题8：改错----数组越界  出现频率：****

面试题9：分析程序---数组越界  出现频率：***

面试题10：分析程序---打印操作可能产生数组越界

面试题11：编程实现计算字符串的长度  出现频率：*****

面试题12：编程实现字符串中子串的查找  出现频率：*****

例：strstr("12345","34")返回值为2，在2号位置找到字符串34

面试题13：编程实现字符串中各单词的翻转  出现频率：***

            例："I am from Shanghai"倒置为"Shanghai from am I“

面试题14：编程判断字符串是否为回文  出现频率：*****

           例：单词"level"是回文

面试题15：编程实现strcmp库函数  出现频率：*****

面试题16：编程查找两个字符串的最大公共子串  出现频率：***

          例：两个字符串A="aocdfe",B="pmcdfa"，输出结果“cdf”

面试题17：不使用printf，将十进制数以二进制和十六进制的形式输出  出现频率：***

面试题18：编程实现转换字符串、插入字符的个数  出现频率：****

面试题19：字符串编码例题  出现频率:**

面试题20：反转字符串，但其指定的子串不反转  出现频率：***

编程题21：编写字符串反转  出现频率：****

         例：输入"abcd",输出应为"dcba"

面试题22：编程实现任意长度的两个正整数相加  出现频率：****

面试题23：编程实现字符串的循环右移  出现频率：****

          例："abcdefghi",如果n=2，移位后应该"hiabcdefg"

面试题24：删除指定长度的字符  出现频率：****

面试题25：字符串的排序和交换  出现频率：***

面试题26：编程实现删除字符串中所有指定的字符  出现频率:****

面试题27：分析代码----使用strcat连接字符串  出现频率：***

面试题28：编程实现库函数strcat  出现频率：*****

编程题29：编程计算含有汉字的字符串长度 出现频率：**

面试题30：编程实现字符串的替换  出现频率：***  

---

面试题1：使用库函数将数字转换为字符串

考点：c语言库函数中数字转换为字符串的使用

出现频率：***

解析：

itoa 将整型值转换为字符串

ltoa 将长整型值转换为字符串

ultoa 将无符号长整型值转换为字符串

gcvt 将浮点型数转换为字符串，取四舍五入

ecvt 将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点

fcvt 以指定位数为转换精度，其余同ecvt

答案：可以使用atoi系列的函数将数字转换为字符串

面试题2：不使用库函数将整数转换成字符串

考点：对数字转换为字符串，相关ASCII码的理解

出现频率：*****

答案:

void int2str(int n, char *str)

{

char buf[10] = "";

int i = 0;

int len = 0;

int temp = n < 0 ? -n:n;

if(NULL == str)

{

return;

}

while(temp)

{

buf[i++] = (temp % 10) + '0';

temp = temp / 10;

}

len = n < 0 ? ++i : i; //如果n是负数，则多需要一位来存储负号

str[i] = 0;

while(1)

{

i--;

if(buf[len-i-1] == 0)

{

break;

}

str[i] = buf[len-i-1];

}

if(0 == i)

{

str[i] = '-';

}

}





int main()

{

int nNum;

char p[10];

cout << "please input an integer:";

cin >> nNum;

cout << "output:";

int2str(nNum, p);

cout << p << endl;

return 0;

}

面试题3：使用库函数将字符串转换为数字

考点：c语言库函数中字符串转换为数字的使用

出现频率：****

解析：

atof 将字符串转换为双精度浮点型值

atoi 将字符串转化为整型值

atol 将字符串转换为长整型值

strtod 将字符串转换为双精度浮点型值，并报告不能被转换的所有剩余数字

strtol 将字符串转换为长整型值，并报告不能被转换的所有剩余数字

strtoul 将字符串转换为无符号长整型值，并报告不能被转换的所有剩余数字

面试题4：不使用库函数将字符串转换为数字

考点：对字符串转换为数字，相关ASCII码的理解

出现频率：****

答案：

int str2int(const char *str)

{

int temp = 0;

const char *ptr = str;

if(*str == '-' || *str == '+')

{

str++; //如果第一个字符是正负号，则移到下一个字符

}

while(*str != 0)

{

if((*str < '0') || (*str > '9'))

{

break;

}

temp = temp * 10 + (*str-'0');

str++;

}

if(*ptr == '-')

{

temp = -temp;

}

return -temp;

}



int main()

{

int n = 0;

char p[10] = "";

cin.getline(p, 20); //从终端获取一个字符串

n = str2int(p); //把字符串转换为整型数

cout << n << endl;

return 0;

}

面试题5：编程实现strcpy函数

考点：字符串复制的实现

出现频率：****

已知strcpy函数的原型是：

char *strcpy(char *strDest, const char *srtSrc);

(1)不调用库函数，实现strcpy函数

(2)解释为什么要返回char *

答案：

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

{

if(strDest == NULL || strSrc == NULL)

{

return NULL;

}

char *strDestCopy = strDest;

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

return strDestCopy;

}





int getStrLen(const char *strSrc)

{

int len = 0;

while(*strSrc++ != '')

{

len++;

}

return len;

}





int main()

{

char strSrc[] = "hello world!";

char strDest[20];

int len = 0;

len = getStrlen(strcpy(strDest, strSrc));

printf("strDest:%sn, strDest);

printf("Length of strDest:%dn", len);

return 0;

}

为什么返回值是char *，是为了使用链式表达式，由于在strcpy中使用了char *返回类型，因此

可以在代码中可以通过链式表达式来同时做两个操作，这样不仅调用方便，而且程序结构简洁明了。

面试题6：编程实现memcpy函数

考点：内存复制的实现

出现频率：****

答案：

#include 

void *memcpy2(void *memTo, const void *memFrom, size_t size)

{

assert((memTo != NULL) && (memFrom != NULL)); //memTo和memFrom必须有效

char *tempFrom = (char *)memFrom;

char *tempTo = (char *)memTo;

while(size-- > 0)

{

*tempTo++ = *tempFrom++;

}

*tempTo = '';

return memTo;

}

面试题7：strcpy与memcpy的区别

考点：字符串复制与内存复制之间的区别

出现频率：****

答案：

1、复制的内容不同，strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、

整型、结构体等

2、复制的方法不同，strcpy不需要指定长度，它是遇到字符串结束符''而结束的，而memcpy

则是根据其第三个参数决定复制的长度

3、用途不同，通常在复制字符串时用strcpy，而若需要复制其他类型数据，则一般用memcpy

面试题8：改错----数组越界

考点：数组越界出现的问题

出现频率：****

试题1：

void test1()

{

char string[10];

char *str1 = "0123456789";

strcpy(string, str1);

}

试题2：

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = 'a';

}

strcpy(string, str1);

}

试题3：

void test3(char *str1)

{

char string[10];

if(strlen(str1) <= 10)

{

strcpy(string, str1);

}

}

答案：这三道题都有数组越界的问题

试题1：

void test1()

{

char string[10]; //改成：char string[11];

char *str1 = "0123456789";

strcpy(string, str1);

}

试题2：

void test2()

{

char string[10], str1[10]; //改成：char string[11], str1[11];

int i;

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

{

str1[i] = 'a';

}

strcpy(string, str1);

}

试题3：

void test3(char *str1)

{

char string[10];

if(strlen(str1) <= 10) //改成：if(strlen(str1) < 10)

{

strcpy(string, str1);

}

}

面试题9：分析程序---数组越界

考点：不当的循环操作导致数组越界

出现频率：***

下面这个程序执行后会出现什么错误或者效果

#define MAX 255

int main()

{

unsigned char A[MAX], i;

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

{

A[i] = i;

}

}

答案：i<=MAX导致数组越界以及无限循环，应该改成i

面试题10：分析程序---打印操作可能产生数组越界

考点：打印操作时可能产生的数组越界问题

下面这个程序的打印结果是什么

int main()

{

int a[5] = {0,1,2,3,4}, *p;

p = a;

printf("%dn", *(p+4*sizeof(int)));

return 0;

}

答案：打印的结果是随机值，因为p+4*sizeof(int)已经越界了

面试题11：编程实现计算字符串的长度

考点：strcpy库函数的实现细节

出现频率：*****

答案：

#include 

#include 



int strlen1(const char *src)

{

assert(NULL != src); //src必须有效

int len = 0;

while(*src++ != '')

len++;

return len;

}





int strlen2(const char *src)

{

assert(NULL != src);

const char *temp = src;

while(*src++ != '');

return (src-temp-1);

}

strlen1用一个局部变量len在遍历的时候做自增，然后返回len，因此，当while循环一次，就

需要执行两次自增操作

strlen2用一个局部变量temp记录src遍历前的位置，while循环一次只需要一次自增操作，最后

返回指针之间的位置差

显然，strlen2比strlen1的效率要高，尤其是在字符串较长的时候。

面试题12 编程实现字符串中子串的查找

考点：strstr库函数的实现细节

出现频率：*****

请写一个函数，实现strstr，即从一个字符串中，查找另一个字符串的位置，如strstr("12345","34")

返回值为2，在2号位置找到字符串34

const char *strstr(const char *src, const char *sub)

{

const char *bp;

const char *sp;

if(src == NULL || NULL == sub)

{

return src;

}

while(*src)

{

bp = src;

sp = sub;

do

{

if(!*sp)

{

return src;

}while(*bp++ == *sp++);

}

src += 1;

}

return NULL;

}





int main()

{

char p[] = "12345";

char q[] = "34";

char *r = strstr(p, q);

printf("r: %sn", r);

return 0;

}

面试题13：编程实现字符串中各单词的翻转

考点：字符串相关的综合编程能力

出现频率：***

编写函数，将"I am from Shanghai"倒置为"Shanghai from am I“，即

句子中的单词位置倒置，而不改变单词内部的结构

答案:

方法一：

void RevStr(char *src)

{

char *start = src, *end = src, *ptr = src;

while(*ptr++ != '') //遍历字符串

{

if(*ptr == ' ' || *ptr == '') //找到一个单词

{

end = ptr-1; //end指向单词末尾

while(start < end)

swap(*start++, *end--); //把单词的字母逆置

start = end = ptr+1; //指向下一个单词开头

}

}

start = src, end = ptr-2; //start指向字符串开头，end指向字符串末尾

while(start < end)

{

swap(*start++, *end--);

}

}

方法二：

void RevStr(char *src)

{

char *start = src, *end = src, *ptr = src;

while(*ptr++ != '');

end = ptr-2; //找到字符串末尾

while(start < end)

{

swap(*start++, *end--); //逆置整个字符串

}

start = src, end = ptr-2;

ptr = start;

while(*ptr++ != '')

{

if(*ptr == ' ' || *ptr == ' ') //找到单词

{

end = ptr-1;

while(start < end)

{

swap(*start++, *end--); //逆置单词

start = end = ptr+1; //指向下一个单词开头

}

}

}

}

面试题14 编程判断字符串是否为回文

考点：字符串相关的综合编程能力

出现频率：*****

判断一个字符串是不是回文，例如单词"level"是回文

答案：

int isRevStr(char *str)

{

int i, len;

int found = 1; //1表示是回文字符串，0表示不是

if(NULL == str)

{

return -1;

}

len = strlen(str);

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

{

if(*(str+i) != *(strlen-i-1)) //遍历中如果发现相应的头尾字符不等

{

found = 0; //则字符串不是回文

break;

}

}

return found;

}

面试题15：编程实现strcmp库函数

考点：库函数strcmp的实现细节

出现频率：*****

答案：

int mystrcmp(const char *src, const char *dst)

{

int ret = 0;

while(!(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst) //循环比较两个字符是否相等

{

++src; //如果不等或者到了dst字符串末尾，则退出循环

++dst;

}

if(ret < 0)

{

ret = -1;

}

else if(ret > 0)

{

ret = 1;

}

return ret;

}

面试题16：编程查找两个字符串的最大公共子串

考点：字符串相关的综合编程能力

出现频率：***

答案：

两个字符串A="aocdfe",B="pmcdfa"，输出结果“cdf”

char *commonstring(char *str1, char *str2)

{

int i, j;

char *shortstr, *longstr;

char *substr;

if(NULL == str1 || NULL == str2)

{

return NULL;

}

if(strlen(str1) <= strlen(str2))

{

shortstr = str1;

longstr = str2;

}

else

{

shortstr = str2;

longstr = str1;

}

if(strstr(longstr, shortstr) != NULL) //如果在长字符串中能找到短的字符串

{

return shortstr;

}

substr = (char *)malloc(sizeof(char) * (strlen(shortstr)+1)); //申请堆内存存放返回结果

for(i = strlen(shortstr)-1; i > 0; i--)

{

for(j = 0; j <= strlen(shortstr)-i; j++)

{

memcpy(substr, &shortstr[j], i); //将短字符串的一部分复制到substr

substr[i] = ''; //其长度逐渐减小

if(strstr(longstr, substr) != NULL) //如果在longstr中能找到substr，则返回substr

{

return substr;

}

}

}

return NULL;

}





int main()

{

char *str1 = (char *)malloc(256);

char *str2 = (char *)malloc(256);

char *common = NULL;

gets(str1);

gets(str2);

common = commonstring(str2, str1);

printf("the longest common string is:%sn", common);

return 0;

}

面试题17：不使用printf，将十进制数以二进制和十六进制的形式输出

考点：用字符串表示十进制数

出现频率：***

答案：如果不能使用printf系列库函数，我们可以通过位运算得到这个十进制的二进制和十六进制形式的字符串，再将字符串打印

char *get2String(long num) //得到二进制形式的字符串

{

int i = 0;

char *buffer;

char *temp;

buffer = (char *)malloc(33);

temp = buffer;

//给数组的32个元素赋‘0’或者‘1’

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

{

temp[i] = num & (1 << (31-i));

temp[i] = temp[i] >> (31-i);

temp[i] = (temp[i] == 0) ? '0' : '1';

}

buffer[32] = '';

return buffer;

}



//得到十六进制形式的字符串

char *get16String(long num)

{

int i = 0;

char *buffer = (char *)malloc(11);

char *temp;

buffer[0] = '0'; //"0x"开头

buffer[1] = 'x';

buffer[10] = '';

temp = buffer+2;

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

{

//给数组的8个元素赋值

temp[i] = (char)(num << 4 * i >> 28);

temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;

temp[i] = temp[i] < 10 ? temp[i] + 48 : temp[i] + 55;

}

return buffer;

}



int main()

{

char *p = NULL;

char *q = NULL;

int num = 0;

printf("input num:");

scanf("%d", &num);

p = get16String(num);

q = get2String(num);

printf("%sn", p);

printf("%sn", q);

return 0;

}

面试题18：编程实现转换字符串、插入字符的个数

考点：字符串相关的综合编程能力

出现频率：****

答案：

根据题意，需要在字符串中插入字符统计的个数，例如字符串aaab，插入字符个数后变成aaa3b1

#define MAXCOUNT 2*100

char *transformation(char *str)

{

int len = strlen(str);

char *buf = new char[len+1];

char *p = str;

char *q = p+1;

int count = 1;

while(*q)

{

if(*p == *q)

{

count++;

p++;

q++;

}

else

{

itoa(count, buf, 10);

int nbits = strlen(buf);

strcat(buf, q);

*q = 0;

strcat(str, buf);

q += nbits;

p = q;

q = p+1;

count = 1;

}

}

itoa(count, buf, 10);

strcat(str, buf);

delete []buf;

buf = NULL;

return str;

}





int main()

{

char str[MAXCOUNT];

printf("please input a string:");

scanf("%s", &str);

printf("before transformation:%sn", str);

char *pstr = transformation(str);

printf("after transformation:%sn", pstr);

return 0;

}

面试题19：字符串编码例题

考点：字符串相关的综合编程能力

出现频率:**

Give an implementation of encoding a string which contains less than 20 chars, There three rules:

1、replace the alphabetical char in the string whih the fourth char behind it, for example:

a -> e, A->E, X->B, y->c, z->d

2、if the char is not a alphabetical char, ignore it

3、reverse the string updated

翻译：

对一个长度小于20的字符串进行编码，遵循3个规则：

1、把字符串中的字母替换成其他的四个字母，例如：

a -> e, A->E, X->B, y->c, z->d

2、如果字符不是字母，忽略替换

3、翻转整个字符串

整个过程可以分为两个部分，替换字符和翻转字符串，其中替换字符还包括一个检查的操作，

即检查是否是在字母表中的字符，也就是英文的26个字符

char LowerCaseAlphabets[] =

{'a','b','c','d','e','f','g','h',

'i','j','k','l','m','n','o','p',

'q','r','s','t','u','v','w','x','y','z'};

char UpperCaseAlphabets[] =

{'A','B','c','D','E','F','G','H',

'I','J','K','L','M','N','O','P',

'Q','R','S','T','U','V','W','X','Y','Z'};

char GetFourthChar(char chrSource, char alphabets[])

{

for(int i = 0; i < 26; i++)

{

if(alphabets[i] == chrSource)

{

int index = (i+4) % 26;

return alphabets[index];

}

}

return '';

}





void ReplaceChars(char chars[], int len)

{

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

{

if('a' <= chars[i] && chars[i] <= 'z')

{

chars[i] = GetFourthChar(chars[i], LowerCaseAlphabets);

}

else if('A' <= chars[i] && chars[i] <= 'Z')

{

chars[i] = GetFourthChar(chars[i], UpperCaseAlphabets);

}

}

}



void ReverseString(char str[], int len)

{

int begin = 0, end = len-1;

if(str[end] == '')

end--;

char hold;

while(begin < end)

{

hold = str[begin];

str[begin] = str[end];

str[end] = hold;

begin++;

end--;

}

}





void EncodeString(char str[], int len)

{

ReplaceChars(str, len);

ReverseString(str, len);

}



int main()

{

char hello[] = "hasd11H";

EncodeString(hello, strlen(hello));

cout << hello << endl;

return 0;

}

结果如下："L11hwel"

面试题20：反转字符串，但其指定的子串不反转

考点：字符串相关的综合编程能力

出现频率：***

给定一个字符串、一个这个字符串的子串，将第一个字符串进行反转，但保留子串的顺序不变

思路：

1、扫描一遍第一个字符串，反转，记录下子串出现的位置

2、扫描一遍记录下来的子串，反转字符串

3、将堆栈里的字符弹出，这样子串又恢复了原来的顺序

扫描一遍数组，扫描中如果发现子串，将子串倒过来压入堆栈，最后将堆栈中的字符弹出，这样子串又恢复了原来的顺序

c++标准库中的stack表是一个后进先出的栈结构

const char *reverse(const char *s1, const char *token)

{

stack stack1;

const char *ptoken = token, *head = s1, *rear = s1;

assert(s1 && token);

while(*head != '')

{

while(*head != '' && *ptoken == *head)

{

ptoken++;

head++;

}

if(*ptoken == '')

{

const char *p;

for(p = head-1; p >= rear; p--)

{

stack1.push(*p);

}

ptoken = token;

rear = head;

}

else

{

stack1.push(*rear++);

head = rear;

ptoken = token;

}

}

char *pReturn = new char[strlen(s1)+1];

int i = 0;

while(!stack1.empty())

{

pReturn[i++] = stack1.top();

stack1.pop();

}

pReturn[i] == '';

return pReturn;

}





int main()

{

char welcome[] = "Welcome you, my friend";

char token[] = "you";

const char *pRev = reverse(welcome, token);

cout << "before reverse:" << endl;

cout << welcome << endl;

cout << "after reverse:" << endl;

cout << pRev << endl;

return 0;

}

编程题21：编写字符串反转函数strrev

考点：字符串相关的综合编程能力

出现频率：****

编写字符串反转函数strrev，要求时间和空间效率都尽量高，测试用例：输入"abcd",输出应为"dcba"

答案：

解法1：遍历字符串第一个字符和最后一个字符进行交换，第二个和倒数第二个进行交换，依次循环

char *strrev1(const char *str)

{

int len = strlen(str);

char *tmp = new char[len+1];

strcpy(tmp, str);

for(int i = 0; i < len/2; i++)

{

char c = tmp[i];

tmp[i] = tmp[len-i-1];

tmp[len-i-1] = c;

}

return tmp;

}

没有考虑到时间和空间的优化，一个典型的优化策略就是两个字符交换的算法优化，可以使用位运算符^完成两个字符的交换

解法2：

char *strrev2(const char *str)

{

char *tmp = new char[strlen(str)+1];

strcpy(tmp, str);

char *ret = tmp;

char *p = tmp + strlen(str)-1;

while(p > tmp)

{

*p = *p + *tmp;

*tmp = *p - *tmp;

*p = *p - *tmp;

--p;

++tmp;

}

return ret;

}



char *strrev3(const char *str)

{

char *tmp = new char[strlen(str)+1];

strcpy(tmp, str);

char *ret = tmp;

char *p = tmp + strlen(str)-1;

while(p > tmp)

{

*p ^= *tmp;

*tmp ^= *p;

*p ^= *tmp;

--p;

++tmp;

}

return ret;

}

还可以使用递归：

解法3：

char *reverse4(char *str, int len)

{

if(len <= 1)

{

return str;

}

char t = *str;

*str = *(str+len-1);

*(str+len-1) = t;

return (reverse5(str+1, len-2-1));

}

以上解法都是在函数体内申请了堆内存

面试题22：编程实现任意长度的两个正整数相加

考点：字符串相关的综合编程能力

出现频率：****

char *addBigInt(char *num1, char *num)

{

int c = 0; //进位，开始最低进位为0

int i = strlen(num1)-1; //指向第一个加数的最低位

int j = strlen(num2)-1; //指向第二个加数的最低位

int maxLength = strlen(num1) >= strlen(num2) ? strlen(num1)+1 : strlen(num2)+1; //得到两个数中较大数的位数

char *rst = (char *)malloc(maxLength+1); //保存结果

int k;

if(rst == NULL)

{

printf("malloc error!n");

exit(1);

}

rst[maxLength] = ''; //字符串最后一位为''

k = strlen(rst)-1; //指向结果数组的最低位

while((i >= 0) && (j >= 0))

{

rst[k] = ((num1[i]-'') + (num[j]-'')+c)%10 + ''; //计算本位的值

c = ((num1[i] - '') + (num2[j]-'')+c)/10; //向高位进值位

--i;

--j;

--k;

}

while(i >= 0)

{

rst[k] = ((num1[i] - '0')+c)%10 + '';

c = ((num[i]-'0')+c) / 10;

--i;

--k;

}

while(j >= 0)

{

rst[k] = ((num2[j] - '0') + c) % 10 + '0';

c = ((num2[j] - '0') + c) / 10;

--j;

--k;

}

rst[0] = c + '0';

if(rst[0] != '0') //如果结果最高位不等于0，则输出结果

{

return rst;

}

else

{

return rst+1;

}

}





int main()

{

char num1[] = "123456789323";

char num2[] = "456712345677889"

char *result = NULL;

result = addBigInt(num1, num2);

printf("%s + %s = %sn", num1, num2, result);

return 0;

}

面试题23：编程实现字符串的循环右移

考点：字符串相关的综合编程能力

出现频率：****

答案：

比如：将"abcdefghi",如果n=2，移位后应该是"hiabcdefg"

void loopMove(char *str, int n)

{

int i = 0;

char *temp = NULL;

int strlen = 0;

char *head = str; //指向字符串头

while(*str++);

strlen = str-head-1; //计算字符串长度

n = n % strlen; //计算字符串尾部移到头部的字符个数

temp = (char *)malloc(n); //分配内存

for(i = 0; i = n; i--)

{

head[i] = head[i-n]; //从头部字符移到尾部

}

for(i = 0; i  
 
 
 
面试题24：删除指定长度的字符
 
 
编程实现从字符串的指定位置开始，删除指定长度的字符
 
 
考点：字符串相关的综合编程能力
 
 
出现频率：****
 
 
答案：
 
假设一个字符串"abcdefg",如果要从第二个开始，索引为1，删除两个字符，删除后的字符串是“adefg”
 
char *deleteChars(char *str, int pos, int len)

{

char *p = str + pos -1; //指向pos位置字符

int tt = strlen(str);

if(pos < 1 || (p-str) > tt) //检查pos是否不大于1或者pos超出字符串长度

{

return str;

}

if((p+len-str) > tt) //len大于pos后剩余的字符个数

{ //只需对pos位置赋''

*p = '';

return str;

}

//删除len个字符

while(*p && *(p+len)) //len小于或等于pos剩余的字符个数

{

*p = *(p+len); //删除中间len个字符

p++;

}

*p = '';

return str;

}
 
 
 
 
面试题25：字符串的排序和交换
 
 
考点：字符串相关的综合编程能力
 
 
出现频率：***
 
 
编写一个函数将一条字符串分成两部分，将前半部分按ASCII码升码排序，后半部分不变，
 
（如果字符串是奇数，则中间的字符不变）再将前后两部分交换，最后将该字符串输出。
 
 
void mysort(char *str, int num)

{

int i, j;

int temp = 0;

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

{

for(j = i+1; j < num; j++)

{

if(str[i] < str[j])

{

temp = str[i];

str[i] = str[j];

str[j] = temp;

}

}

}

}



char *foo(char *str)

{

int len = 0;

chJHGIar *start = NULL;

if(NULL == str)

{

return NULL;

}

start = str; //保存头部位置

while(*str++);

len = str-start-1; //计算字符串长度

len = len / 2; //计算需要排序的字符个数

str = start;

mysort(str, len);

return str;

}





int main()

{

char str[] = "ADZDDJKJFIEJHGI";

printf("before transformation:%sn", string);

foo(string);

printf("after transformation:%sn", string);

return 0;

}
 
 
 
 
面试题26：编程实现删除字符串中所有指定的字符
 
 
考点：字符串相关的综合编程能力
 
 
出现频率:****
 
 
答案:
 
char *deleteChar(char *str, char c)

{

char *head = NULL;

char *p = NULL;

if(str == NULL)

{

return NULL;

}

//指向字符串头，准备遍历

head = p = str;

while(*p++)

{

//如果不等于c，就重新赋值给str

if(*p != c)

{

*str++ = *p;

}

}

*str = '';

return head;

}
 
 
 
 
面试题27：分析代码----使用strcat连接字符串
 
 
考点：字符串相关的综合编程能力
 
 
出现频率：***
 
 
下面的程序代码有什么问题吗？输出是什么？
 
int main()
 
{
 
char *str1 = "hello";
 
char *str2 = "china";
 
char *str3 = NULL;
 
str3 = new char[strlen(str1) + strlen(str2) + 1];
 
str3[0] = 'n';
 
strcat(str3, str1);
 
strcat(str3, str2);
 
cout << str3 << endl;
 
return 0;
 
}
 
答案:没有对str3清0，会连接越界
 
将str3[0] = 'n';改为str3[0] = '';
 
 
 
 
面试题28：编程实现库函数strcat
 
 
考点：库函数strcat的实现细节
 
 
出现频率：*****
 
 
答案:
 
char *mystrcat(char *dest, const char *src)

{

char *ret;

ret = dest;

while(*dest++);

dest--; //此时dest指向字符串结束符

while(*dest++ == *src++); //循环赋值

return ret;

}



int main()

{

char *dest = NULL;

char *str1 = "hello";

char *str2 = "world";

dest = (char *)malloc(256);

*dest = '';

mystrcat(mystrcat(dest, str1), str2);

printf("dest:%sn", dest);

free(dest);

return 0;

}
 
 
 
 
编程题29：编程计算含有汉字的字符串长度
 
 
考点：字符串相关的综合编程能力
 
 
出现频率：**
 
 
答案：
 
编写gbk_strlen函数，计算含有汉字的字符串的长度，汉字作为一个字符处理，已知汉字编码为双字节，
 
其中首字节<0，尾字节在0-63以外（如果一个字节是-128~127）
 
int gdk_strlen(const char *str)

{

const char *p = str;

while(*p)

{

if(*p < 0 && (*(p+1) < 0 || *(p+1) > 63)

{

str++:

p += 2;

}

else

{

p++;

}

}

return p-str;

}
 
 
注意：汉字算一个字符长度
 
 
 
 
面试题30：编程实现字符串的替换
 
 
考点：字符串相关的综合编程能力
 
 
出现频率：***
 
 
用c++写一个小程序，先请用户输入3个字符串，然后把在第一个字符串中出现的所有第二个字符串
 
替换成第三个字符串，最后输出新的字符串
 
 
答案:
 
char *replace(const char *str, const char *sub1, const char *sub2, char *output)

{

char *pOutput = NULL;

const char *pStr = NULL;

int lenSub1 = strlen(sub1);

int lenSub2 = strlen(sub2);

pOutput = output;

pStr = str; //用于寻找子串

while(*pStr != 0)

{

pStr = strstr(pStr, sub1); //在str中寻找sub1子串

if(NULL != pStr) //找到str1子串

{

memcpy(pOutput, str, pStr-str); //复制str的前一部分output

pOutput += pStr - str;

memcpy(pOutput, sub2, lenSub2); //复制sub2子串到output

pOutput += lenSub2;

pStr += lenSub1; //为了下一次复制做准备

str = pStr;

}

else

{

break;

}

}

*pOutput = '';

if(*str != '')

{

strcpy(pOutput, str); //复制str剩余部分到output

}

return output;

}