C语言：将一句话的单词进行倒置，标点不倒置。-Toy模板网

这篇具有很好参考价值的文章主要介绍了C语言：将一句话的单词进行倒置，标点不倒置。。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

题目：

将一句话的单词进行倒置，标点不倒置。（字符数组长度不超过100）

比如：I like beijing.

经过函数后变为：beijing. like I

=========================================================================

思路：

总体思路：

（可以把两步顺序调换）

第一步：把整个字符串逆序

（知道整个字符串的首尾地址后，一对一对向整个字符串中间靠拢交换）

第二步：再逆序每个单词
（知道每个单词的首尾地址后，一对一对向单词中间靠拢交换）



两步中逆序的方法是一样的，可以写一个相应的自定义函数reverse



补充知识点一：gets()

读取一个字符串，即使中间有空格

gets(arr); -- 把读取到的字符串放进字符串数组arr中

（编译器可能会觉得该函数不安全而报警告，因为读取的字符串放进数组后可能会导致数组越界，可能会报错爆红，但还是可以用的）



补充知识点二：fgets()

可以使用 fgets()函数替代 gets()函数

fgets(arr, 100, stdin);

函数参数：

arr：把读取的字符串放进字符数组arr中

100：获取字符串最大字符数，这里设置为100

stdin：输入方式，stdin 为键盘输入

（因为指定了获取的字符个数，所以不用担心数组越界，也就不会报警告）



第一步：

完成逆序自定义函数reverse 编写：

（1）.

函数参数：

char* left -- 左元素位置

char* right -- 右元素位置

（2）.

使用 while循环，left < right 就继续循环逆序，因为此时数组还有数，



使用临时变量tmp，进行数组元素调换，

调换一次后就调整一次左右位置

实现代码：
#include <stdio.h>

//逆序自定义函数 reverse：
void reverse(char* left, char* right)
{
	//使用while循环：
	while (left < right)
	//左小于右，说明中间还有值且没有指向一个字符，继续逆序
	{
		//使用临时变量tmp进行逆序：
		char tmp = *left;
		*left = *right;
		*right = tmp;
		//调换后调整左右位置
		left++;
		right--;
	}
}

int main()
{

}
实现图片：

第二步：

主函数：



（1）. 定义字符数组，数组长度不超过100，那就设置为101

（2）. 使用 gets(arr); 把读取到的字符串放进字符串数组arr中



（3）. 求字符串长度 -- strlen(arr); 需要头文件<string.h>



（4）. 使用逆序自定义函数reverse 逆序整个字符数组，

将整个数组arr的左右下标传给函数reverse即可

实现代码：
#include <stdio.h>
#include <string.h>

//逆序自定义函数 reverse：
void reverse(char* left, char* right)
{
	//使用while循环：
	while (left < right)
	//左小于右，说明中间还有值且没有指向一个字符，继续逆序
	{
		//使用临时变量tmp进行逆序：
		char tmp = *left;
		*left = *right;
		*right = tmp;
		//调换后调整左右位置
		left++;
		right--;
	}
}

int main()
{
	//定义字符数组：
	char arr[101];

	//使用 gets(arr) 获取字符串
	gets(arr);

	//求字符串长度：
	int len = strlen(arr);
	//strlen 不会把 \0 计算进去，找到 \0 就停了
	//需要头文件：<string.h>

	//逆序整个字符串：
	reverse(arr, arr + len - 1); //调用自定义逆序函数
	//函数参数：数组首地址（左指针）、最后一个字符的地址（右指针）
	//arr+len-1：首地址 + 数组长度 - 1 --> 最后一个字符的地址
}
实现图片：

第三步：

主函数：逆序整个单词：

（1）. 定义单词的起始和尾部位置：

char* start; -- 单词起始位置

char* cur; -- 单词尾部位置



（2）. 使用 while循环循环查找单词并逆序单词，

*cur 单词尾部还没有到结束符 '\0' 就继续找单词



（3）. 内嵌 while循环，调整 cur 单词尾部位置：

*cur 单词尾部还没有到空格（每个单词间隔一个空格）

且

还没到结束符 '\0'

就 cur++ ，调整当前单词尾部位置

（4）. 经过上一个步骤，找到了第一个单词（第一次while循环）,

对该单词进行逆序：

调用逆序函数reverse，

将该单词的首位（左右）位置传给reverse即可

（5）. 调整 start 单词起始位置，到下一个单词的起始位置：

start = cur +1; -- cur + 1, 空格后的下一个位置就是下一个单词的起始位置

（6）. 调整 cur 单词尾部位置，

先使用 if条件判断语句调整到空格后一位，即单词起始位置，

再在下一次循环通过内嵌的 while循环调整到该单词的尾部位置



实现代码：
#include <stdio.h>
#include <string.h>

//逆序自定义函数 reverse：
void reverse(char* left, char* right)
{
	//使用while循环：
	while (left < right)
	//左小于右，说明中间还有值且没有指向一个字符，继续逆序
	{
		//使用临时变量tmp进行逆序：
		char tmp = *left;
		*left = *right;
		*right = tmp;
		//调换后调整左右位置
		left++;
		right--;
	}
}

int main()
{
	//定义字符数组：
	char arr[101];

	//使用 gets(arr) 获取字符串
	gets(arr);

	//求字符串长度：
	int len = strlen(arr);
	//strlen 不会把 \0 计算进去，找到 \0 就停了
	//需要头文件：<string.h>

	//逆序整个字符串：
	reverse(arr, arr + len - 1); //调用自定义逆序函数
	//函数参数：数组首地址（左指针）、最后一个字符的地址（右指针）
	//arr+len-1：首地址 + 数组长度 - 1 --> 最后一个字符的地址

	//逆序每个单词：
	//定义 单词的 起始 和 尾部 位置：
	char* start = arr; //单词起始位置
	char* cur = arr; //单词尾部位置，后面再调整

	//使用 while循环 循环查找并逆序单词：
	while (*cur != '\0')
	//整个字符串还没结束，继续找单词
	{
		//内嵌 while循环 调整单词尾部位置cur：
		while (*cur != ' ' && *cur != '\0')
		//单词尾部未找到空格且还没有结束符就继续往后移一位
		{
			cur++;//往后移一位
		}//直到找到单词，此时在空格位置

		//找到单词后进行单词逆序：
		reverse(start, cur - 1);
		//因为单词尾部 cur 此时在 空格位置，
		//所以要在空格（或\0，最后一个单词）位置前-1

		//找下一个单词：
		//调整start单词起始位置：
		start = cur + 1;
		//cur+1，空格后的下一个位置就是下一个单词的首地址

		//调整单词尾部位置：
		if (*cur == ' ')
		//只有是空格时才能跳过，\0不能再跳过了，不然就跳不出循环了
		{
			cur++;//调整下一个单词尾部位置到起始位置
		}
	}

}
实现图片：

第四步：

两个逆序都完成后，进行打印

实现代码：
#include <stdio.h>
#include <string.h>

//逆序自定义函数 reverse：
void reverse(char* left, char* right)
{
	//使用while循环：
	while (left < right)
	//左小于右，说明中间还有值且没有指向一个字符，继续逆序
	{
		//使用临时变量tmp进行逆序：
		char tmp = *left;
		*left = *right;
		*right = tmp;
		//调换后调整左右位置
		left++;
		right--;
	}
}

int main()
{
	//定义字符数组：
	char arr[101];

	//使用 gets(arr) 获取字符串
	gets(arr);

	//求字符串长度：
	int len = strlen(arr);
	//strlen 不会把 \0 计算进去，找到 \0 就停了
	//需要头文件：<string.h>

	//逆序整个字符串：
	reverse(arr, arr + len - 1); //调用自定义逆序函数
	//函数参数：数组首地址（左指针）、最后一个字符的地址（右指针）
	//arr+len-1：首地址 + 数组长度 - 1 --> 最后一个字符的地址

	//逆序每个单词：
	//定义 单词的 起始 和 尾部 位置：
	char* start = arr; //单词起始位置
	char* cur = arr; //单词尾部位置，后面再调整

	//使用 while循环 循环查找并逆序单词：
	while (*cur != '\0')
	//整个字符串还没结束，继续找单词
	{
		//内嵌 while循环 调整单词尾部位置cur：
		while (*cur != ' ' && *cur != '\0')
		//单词尾部未找到空格且还没有结束符就继续往后移一位
		{
			cur++;//往后移一位
		}//直到找到单词，此时在空格位置

		//找到单词后进行单词逆序：
		reverse(start, cur - 1);
		//因为单词尾部 cur 此时在 空格位置，
		//所以要在空格（或\0，最后一个单词）位置前-1

		//找下一个单词：
		//调整start单词起始位置：
		start = cur + 1;
		//cur+1，空格后的下一个位置就是下一个单词的首地址

		//调整单词尾部位置：
		if (*cur == ' ')
		//只有是空格时才能跳过，\0不能再跳过了，不然就跳不出循环了
		{
			cur++;//调整下一个单词尾部位置到起始位置
		}
	}

	//两个逆序都完成后，进行打印：
	printf("%s", arr);

}
实现图片：

最终代码和实现效果

最终代码：

#include <stdio.h>
#include <string.h>

//逆序自定义函数 reverse：
void reverse(char* left, char* right)
{
	//使用while循环：
	while (left < right)
	//左小于右，说明中间还有值且没有指向一个字符，继续逆序
	{
		//使用临时变量tmp进行逆序：
		char tmp = *left;
		*left = *right;
		*right = tmp;
		//调换后调整左右位置
		left++;
		right--;
	}
}

int main()
{
	//定义字符数组：
	char arr[101];

	//使用 gets(arr) 获取字符串
	gets(arr);

	//求字符串长度：
	int len = strlen(arr);
	//strlen 不会把 \0 计算进去，找到 \0 就停了
	//需要头文件：<string.h>

	//逆序整个字符串：
	reverse(arr, arr + len - 1); //调用自定义逆序函数
	//函数参数：数组首地址（左指针）、最后一个字符的地址（右指针）
	//arr+len-1：首地址 + 数组长度 - 1 --> 最后一个字符的地址

	//逆序每个单词：
	//定义 单词的 起始 和 尾部 位置：
	char* start = arr; //单词起始位置
	char* cur = arr; //单词尾部位置，后面再调整

	//使用 while循环 循环查找并逆序单词：
	while (*cur != '\0')
	//整个字符串还没结束，继续找单词
	{
		//内嵌 while循环 调整单词尾部位置cur：
		while (*cur != ' ' && *cur != '\0')
		//单词尾部未找到空格且还没有结束符就继续往后移一位
		{
			cur++;//往后移一位
		}//直到找到单词，此时在空格位置

		//找到单词后进行单词逆序：
		reverse(start, cur - 1);
		//因为单词尾部 cur 此时在 空格位置，
		//所以要在空格（或\0，最后一个单词）位置前-1

		//找下一个单词：
		//调整start单词起始位置：
		start = cur + 1;
		//cur+1，空格后的下一个位置就是下一个单词的首地址

		//调整单词尾部位置：
		if (*cur == ' ')
		//只有是空格时才能跳过，\0不能再跳过了，不然就跳不出循环了
		{
			cur++;//调整下一个单词尾部位置到起始位置
		}
	}

	//两个逆序都完成后，进行打印：
	printf("%s", arr);

}