1. 首页
  2. 文章中心
  3. 零基础玩转C语言

【C进阶】鹏哥带你玩转 · 字符串和内存函数一、常见字符串库函数介绍二、字符分类函数三、常见内存操作函数四、遇见安然遇见你，不负代码不负卿。

121 阅读 0 评论
我是靠谱客的博主 寒冷花瓣，这篇文章主要介绍【C进阶】鹏哥带你玩转 · 字符串和内存函数一、常见字符串库函数介绍二、字符分类函数三、常见内存操作函数四、遇见安然遇见你，不负代码不负卿。，现在分享给大家，希望可以做个参考。

大家好，我是安然无虞。

目录

​

一、常见字符串库函数介绍

1、strlen()

自定义函数模拟实现strlen

2、strcpy()

自定义函数模拟实现strcpy

3、strcat()

自定义函数模拟实现strcat

4、strcmp()

自定义函数模拟实现strcmp

5、strncpy()

6、strncat()

7、strncmp()

8、strstr()

自定义函数模拟实现strstr

9、strtok()

10、strerror()

二、字符分类函数

三、常见内存操作函数

1、memcpy()

自定义函数模拟实现memcpy

2、memmove()

自定义函数模拟实现memmove

3、memcmp()

4、memset()

四、遇见安然遇见你，不负代码不负卿。

前言：

前段时间状态不好，所以已经有24天没有更新了，打开手机有很多铁子的消息没有及时回复，这几天正在陆陆续续回，实在抱歉，感谢大家的支持与陪伴，现在的话我正开始慢慢追，一起加油。 

一、常见字符串库函数介绍

C语言中对字符和字符串的操作处理很是频繁，但是C语言本身是没有字符串类型的，所以C语言中的字符串通常放在常量字符串中或者字符数组中；

字符串常量适用于那些对它不作任何修改的字符串函数。

本章重点：

求字符串长度

  • strlen

长度不受限制的字符串库函数

  • strcpy
  • strcat
  • strcmp

长度受限制的字符串库函数

  • strncpy
  • strncat
  • strncmp

字符串查找

  • strstr
  • strtok

错误信息报告

  • strerror

字符操作库函数

内存操作库函数

  • memcpy
  • memmove
  • memset
  • memcmp

注意：

长度不受限制表示的是一直追加到 '' ，跟长度无关；

长度受限制表示跟长度有关，可能这样说不好理解，别担心，看到后面你就明白了。 

1、strlen()

函数原型：

函数功能：

求字符串的长度 

注意：返回值类型是 size_t，这 size_t 到底是什么？

其实 size_t 是为 sizeof 操作符返回值设计的，可以浅显的认为 size_t 就是我们熟知的 unsigned int ，因为是求长度，所以肯定不会是负数，故而使用无符号整型，但是由此也容易产生 bug，请看下面代码：

解读下面代码，请问输出结果是什么：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	if (strlen("abc") - strlen("abcdef") > 0)
		printf(">");
	else
		printf("<=");
	return 0;
}

没错，答案是输出 ">"，为什么呢？3 - 6 = -3鸭，这是怎么回事？

这是因为strlen的返回值是 size_t ，属于无符号数，所以两个无符号数相减，答案一定是无符号数，如果大家还是不明白的话，可以看看这篇文章，说的很清楚哦。

深度剖析数据在内存中的存储https://bit-runout.blog.csdn.net/article/details/121576136那怎么修改呢？

方案一：强制类型转换

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	if ((int)strlen("abc") - (int)strlen("abcdef") > 0 )
		printf(">");
	else
		printf("<=");
	return 0;
}

方案二：直接比较

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	if (strlen("abc") > strlen("abcdef"))
		printf(">");
	else
		printf("<=");
	return 0;
}

注意：

  • 字符串以 '' 作为结束标志，strlen 返回的是在字符串中 '' 之前的字符个数（不包括''）;
  • 参数中指向的字符串必须以 '' 结束；
  • 注意strlen函数的返回值是 size_t 类型，属于无符号类型（特易错）

代码示例：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string>

int main()
{
    int len = strlen("abcdef");
	printf("%dn", len);

	return 0;
}

自定义函数模拟实现strlen

【手把手带你刷LeetCode】——18.自定义函数实现strlen()功能（作业）_安然无虞的博客-CSDN博客今天是力扣打卡第18天！这道题并不是力扣上面的题目，而是一道作业，鹏哥说很重要，我便把它整理成一篇小博文了。原题：自定义函数实现strlen()功能先让我们感受一下strlen()函数：#include<stdio.h>#include<string.h>int main(){char arr[] = "abcdefghij";printf("%dn", strlen(arr));//输出10return 0;}strlen().https://bit-runout.blog.csdn.net/article/details/121381957方法：

  1. 计数器的方法
  2. 递归的方法
  3. 指针 - 指针

方法一：计数器的方法

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
int my_strlen(const char* str)
{
	assert(str);//断言str非空
	int count = 0;
	while (*str != '')
	{
		count++;
		str++;
	}
	return count;
}

方法二：递归的方法

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
int my_strlen(const char* str)
{
	assert(str);//断言str非空
	//找边界
	if (*str == '')
	{
		return 0;
	}
	int count = my_strlen(str + 1);
	//注意str++和str+1是不同的概念
	count++;
	return count;
}

这里需要注意的是，str++ 和 str+1 不是一个概念，str++是先使用后++，本题可以写成++str的形式，先++再使用。

方法三：指针 - 指针

指针-指针其实表示的是两个指针中间的元素个数，注意哦，不是中间有几个字节。

复制代码
1
2
3
4
5
6
7
8
9
10
int my_strlen(const char* str)
{
	assert(str);
	const char* cur = str;
	while (*cur != '')
	{
		cur++;
	}
	return cur - str;
}

2、strcpy()

函数原型：

函数功能： 

 将源字符串拷贝到目标字符串，返回目标字符串首元素的地址。 

解读下列代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = { 0 };
	printf("%sn", strcpy(arr2, arr1));

	return 0;
}

本题是将字符串 arr2 拷贝给字符串 arr1 ，返回的是 arrr2 首元素的地址（目标字符串首元素的地址）。所以上面代码输出的是：abcdef，那么这里的问题是，会不会将字符串arr1中的 '' 拷贝给字符串 arr2 ，所以这里用以下代码验证这个问题：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = "XXXXXXXXXX";
	printf("%sn", strcpy(arr2, arr1));

	return 0;
}

首先，还没有将字符串 arr1 拷贝给 arr2 时，它们存放的数据是这样的：

当执行 strcpy(arr2, arr1) 完后，此时 arr2 中存放的数据是这样的：

可以看到，将字符串 arr1（源字符串） 拷贝给字符串 arr2（目标字符串） 时会自动将源字符串末尾的 '' 拷贝过去，返回的是目标字符串起始位置的地址。

这里又有一个问题是：如果源字符串末尾没有加上 '' （这里用字符数组的形式演示，正常的字符串末尾会自动填充 ''），请看如下代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = { 'a','b','c','d','e','f' };
	char arr2[20] = "XXXXXXXXXX";
	
	printf("%sn", strcpy(arr2, arr1));
	return 0;
}

代码执行结果：

所以需要注意的是：如果想将源字符串拷贝给目标字符串，那么就要保证源字符串中是包含 '' 的，否则会拷贝失败。 

所以，使用 strcpy 拷贝字符串是需要注意以下几点：

  • 源字符串必须以 '' 结束；
  • 拷贝时会将源字符串中的 '' 一同拷贝给目标字符串；
  • 目标字符串（目标空间）必须足够大，以确保能存放源字符串 ；
  • 还有一点就是，目标字符串必须是可以改变的

请看下面的代码：

复制代码
1
2
3
4
5
6
7
8
9
10
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdef";
	const char* p = "XXXXXXXXXX";
	printf("%sn", strcpy(p, arr1));
	return 0;
}

执行程序是错误的，因为此时的目标字符串是被 const 修饰的，是不可以修改的。 

自定义函数模拟实现strcpy

【手把手带你刷好题】——22.面试题：模拟实现strcpy库函数（非力扣）_安然无虞的博客-CSDN博客【前言】今天是刷题打卡第22天！这是一道很好的题目哦，里面有一些很好的coding技巧，要留心看哦。原题：模拟实现strcpy库函数OK，废话不多说，直接上代码...初级代码：满分10分---得5分#include<stdio.h>void my_strcpy(char* dest, char* src){while (*src != ''){*dest = *src;dest++;src++;}*dest =https://bit-runout.blog.csdn.net/article/details/121457507代码执行： 

复制代码
1
2
3
4
5
6
7
8
9
10
11
char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest++ = *src++)//很妙
	{
		;
	}
	return ret;
}

3、strcat()

函数原型：

函数功能： 

将源字符串追加到目标字符串的后面，返回目标字符串首字符的地址 

解读下列代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";

	strcat(arr1, arr2);
	printf("%sn", arr1);
	return 0;
}

以上代码是将 "world" 拼接到 "hello" 的后面，所以打印结果如下：

其实，使用 strcat 库函数的注意事项与 strcpy 是十分相似的，在这里的话我就不重复解释了：

  • 源字符串必须以 '' 结束；
  • 目标空间必须足够大，能容纳下源字符串的内容；
  • 目标空间必须可变。

那么试想：如果让我们自己实现 strcat 函数，该怎么做呢？先想一下大致思路，我们首先要找到目标字符串的结束标志''，然后将源字符串拼接到目标字符串的后面，最后返回目标字符串的首字符的地址，看起来好像挺简单的，那我们实现一下：

自定义函数模拟实现strcat

代码执行：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	//1、找到目标字符串的
	while (*dest)//注意循环条件写成*dest++是错误的，因为会跳过，请细品
	{
		dest++;
	}
	//2、拷贝源字符串
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

4、strcmp()

函数原型：

函数功能： 

比较对应位置上字符的字典序 

标准规定：

  • 第一个字符串 > 第二个字符串，则返回大于0的数字；
  • 第一个字符串 == 第二个字符串，则返回0；
  • 第一个字符串 < 第二个字符串，则返回小于0的数字。

敲黑板：

两个字符串不能直接进行比较，也不能直接进行相加相减运算，因为字符串表示的是首字符的地址。也就是说，如果直接进行比较的话，比的不是字符串的内容，而是地址，所以是错误的。 

自定义函数模拟实现strcmp

代码执行：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)//注意是在循环体中判断相等的情况，想想为什么
	{
		if (*str1 == '')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)//return *str1 - *str2;
		return 1;
	else
		return -1;
}

5、strncpy()

函数原型：

看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "xxxxxxxxxxxxxx";
	char arr2[] = "hello world";
	strncpy(arr1, arr2, 5);
	printf("%sn", arr1);
	return 0;
}

这样的函数相对来说更加安全，更加可控灵活一些。 

6、strncat()

函数原型：

看一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[20] = "helloxxxxx";
	char arr2[] = "world";
	strncat(arr1, arr2, 3);
	printf("%sn", arr1);
	return 0;
}

 

从上面我们能看出，追加完后会自动填充 '' ，而且是追加到目标字符串中第一个 '' 的后面。

7、strncmp()

函数原型：

看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "acbdef";
	char arr2[] = "abcdef";
	int ret = strncmp(arr1, arr2, 3);
	printf("%dn", ret);
	return 0;
}

注意：以上代码比较的是字符串的前三个字符，而不是第三个字符。

8、strstr()

函数原型：

返回值： 

函数功能：

查找字符串

看一下下面的代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "bcd";

	char* ret = strstr(arr1, arr2);

	if (NULL == ret)
		printf("没找到n");
	else
		printf("%sn", ret);
	return 0;
}

 

自定义函数模拟实现strstr

代码执行：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
char* my_strstr(const char* str, const char* substr)
{
	const char* s1 = str;
	const char* s2 = substr;
	const char* cur = str;

	assert(str && substr);
	//特殊情况
	if (*substr == '')
		return (char*)str;
	while (*cur)
	{
		s1 = cur;
		s2 = substr;
		while (*s1 && *s2 && *s1 == *s2)//注意*s1!='&&*s2!='
		{
			s1++;
			s2++;
		}
		if (*s2 == '')
			return (char*)cur;
		cur++;
	}
	return NULL;
}

9、strtok()

函数原型：

使用前注意事项：

  • sep参数是个字符串，定义了用作分隔符的字符集合；
  • 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记 ；
  • strtok函数找到str中的下一个标记，并将其用 '' 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）；
  • strtok函数的第一个参数不为NULL时，函数将找到str中的第一个标记，strtok函数将保存它在字符串中的位置；
  • strtok函数的第一个参数为NULL时，函数将在同一个字符串中被保存的位置开始，查找下一个标记；
  • 如果字符串中不存在更多的标记，则返回NULL指针

也可以这样说：

  • strtok函数找第一个标记的时候，函数的第一个参数不是NULL；
  • strtok函数找非第一个标记的时候，函数的第一个参数是NULL

看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
#include<string.h>

int main()
{
	const char* p = "@.";
	char arr[] = "zpengwei@yeah.net";
	char buf[50] = { 0 };//作为临时拷贝
	strcpy(buf, arr);
	char* str = strtok(buf, p);
	printf("%sn", str);//zpengwei
	str = strtok(NULL, p);
	printf("%sn", str);//yeah
	str = strtok(NULL, p);
	printf("%sn", str);//net
	return 0;
}

不过这样使用看起来太繁琐了，看看下面的改进代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>
#include<string.h>

int main()
{
	const char* p = "@.";
	char arr[] = "zpengwei@yeah.net";
	char buf[50] = { 0 };//作为临时拷贝
	strcpy(buf, arr);
	char* str = NULL;
	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%sn", str);
	}
	//char* str = strtok(buf, p);
	//printf("%sn", str);//zpengwei
	//str = strtok(NULL, p);
	//printf("%sn", str);//yeah
	//str = strtok(NULL, p);
	//printf("%sn", str);//net
	return 0;
}

10、strerror()

函数原型：

返回值：

函数功能：

返回错误码所对应的错误信息

看下面这段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//C语言可以操作文件
//打开文件 - fopen

//当库函数使用的时候，发生错误会把errno这个全局的错误变量设置为本次执行库函数产生的错误码
//errno是C语言提供的一个全局变量，可以直接使用，放在errno.h文件中的
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (NULL == pf)
	{
		//出错误的原因是什么
		printf("%sn", strerror(errno));
		return 0;
	}
	//读文件
	//...

	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

常见字符串库函数终于讲解完了，换换心情。

二、字符分类函数

使用字符操作函数需要注意的是头文件为ctype.h

下面函数比较简单，就不详细介绍了。

字符转换：

  • int tolower(int c)
  • int toupper(int c)

代码示例：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<ctype.h>

int main()
{
	char ch = 0;
	ch = getchar();
	if (islower(ch))
		ch = toupper(ch);
	else
		ch = tolower(ch);

	printf("%cn", ch);

	return 0;
}

三、常见内存操作函数

1、memcpy()

函数原型：

注意哦，内存操作函数中的第三个参数单位是字节。

想想为什么是void*类型？

因为设计者在设计这个库函数的时候不知道会用来拷贝何种类型，所以只有设计成void*最合适。 

看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };
	memcpy(arr2, arr1 + 5, 5 * sizeof(arr1[0]));

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	 }
	return 0;
}

自定义函数模拟实现memcpy

代码执行： 

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;//注意返回类型是void*,而不是void，
	assert(dest && src);
	while (num--)//先使用，后--
	{
		*(char*)dest = *(char*)src;//想想为什么强制类型转换成char*，因为只有它最合适
		dest = (char*)dest + 1;//注意直接进行dest++,src++是错误的，因为它是空类型
		src = (char*)src + 1;
	}
	return ret;
}

2、memmove()

函数原型：

其实C语言只要求：

memcpy能拷贝不重叠的内存空间就可以了，memmove去处理那些重叠的内存拷贝，也就是说，如果记memcpy的功能是A，那么memmove的功能就是A+B 

那么何为重叠的内存拷贝呢，请看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	
	memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));//处理同一块空间时会发生重叠内存拷贝

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	 }
	return 0;
}

自定义函数模拟实现memmove

代码执行：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)//从前向后拷贝
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else//从后向前拷贝
	{
		//src = (char*)src + num - 1;//注意一定要-1
		//dest = (char*)dest + num - 1;
		//while (num--)
		//{
		//	*(char*)dest = *(char*)src;
		//	dest = (char*)dest - 1;
		//	src = (char*)src - 1;
		//}
		while (num--)//先使用，后--，在循环体中是--后的num（真的妙）
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

3、memcmp()

函数原型：

 返回值：

 比较简单，看一下下面的代码：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,7,4,5 };
	int arr2[] = { 1,2,3,4,5 };
	int ret = memcmp(arr1, arr2, 9);

	printf("%dn", ret);
	return 0;
}

4、memset()

函数原型：

函数参数：

 函数功能：

以字节为单位设置内存 

看下面一段代码：

复制代码
1
2
3
4
5
6
7
8
9
10
#include<stdio.h>
#include<string.h>

int main()
{
	char arr[20] = { 0 };
	memset(arr, 'x', 10);
	printf("%sn", arr);
	return 0;
}

 

也可以对整型进行操作，不过因为是对内存进行操作，所以要考虑到大小端字节序的问题，如果大家忘记了何为大小端，可以看看这篇文章：

【手把手带你刷好题】——27.大小端字节序判断（非力扣，百度笔试题）_安然无虞的博客-CSDN博客【前言】今天是刷题打卡第27天！感谢的陪伴，你们的认可就是我最大的动力，抱拳了哈！！大小端引入看一下下面这段代码：#include<stdio.h>int main(){int a = 0x11223344;return 0;}在内存中存储的顺序不对呀，这是为什么？这里就要介绍大小端了。什么是大端小端？大端字节序存储：当一个数据的低位放到高地址处，数据的高位放到低地址处；小端字节序存储：当一个数据的低位放到低地址处，数https://bit-runout.blog.csdn.net/article/details/121583724

四、遇见安然遇见你，不负代码不负卿。

万字博文，原创不易。

求个三连

最后

以上就是寒冷花瓣最近收集整理的关于【C进阶】鹏哥带你玩转 · 字符串和内存函数一、常见字符串库函数介绍二、字符分类函数三、常见内存操作函数四、遇见安然遇见你，不负代码不负卿。的全部内容，更多相关【C进阶】鹏哥带你玩转内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(80)

相关文章

python接口自动化（十八）--重定向（Location）（详解）
python接口自动化（十八）--重定向（Location）（详解）
[算法]位运算问题之二
[算法]位运算问题之二
位运算解决“一个数组中，只有一个数字出现n次，其他数字出现k次”问题
位运算解决“一个数组中，只有一个数字出现n次，其他数字出现k次”问题
小白也能学懂的XCPC第三站——习题课+双指针+位运算+离散化+区间合并。手把手教，萌新也能看懂的基础算法教程！前言二、计算逆序对数量（归并排序的延伸）三、双指针四、位运算五、区间合并六、整数的保序离散化
小白也能学懂的XCPC第三站——习题课+双指针+位运算+离散化+区间合并。手把手教，萌新也能看懂的基础算法教程！前言二、计算逆序对数量（归并排序的延伸）三、双指针四、位运算五、区间合并六、整数的保序离散化
【C进阶】鹏哥带你玩转 · 字符串和内存函数一、常见字符串库函数介绍二、字符分类函数三、常见内存操作函数四、遇见安然遇见你，不负代码不负卿。
【C进阶】鹏哥带你玩转 · 字符串和内存函数一、常见字符串库函数介绍二、字符分类函数三、常见内存操作函数四、遇见安然遇见你，不负代码不负卿。
【每日一题】找到出现了K次的数
【每日一题】找到出现了K次的数
《剑指offer》面试题41：和为s的两个数字 VS 和为s的连续正数序列和为s的两个数字和为s的连续正数序列
《剑指offer》面试题41：和为s的两个数字 VS 和为s的连续正数序列和为s的两个数字和为s的连续正数序列
和为s的连续正数序列
和为s的连续正数序列

评论列表共有 0 条评论

立即
投稿
返回
顶部