利用三步翻转法解决字符串左旋问题

在我们平时写题的时候，经常会遇到移动字符串的要求。今天，我们就来学习一种解题思想 - 三步翻转法

---

零、思想

首先划分为两部分：X: … Y: …
1.左边翻转： X->X^T
2.右边翻转 Y->Y^T
3.整体翻转： (X^TY ^T) ^T=YX

一、倒置字符串

将一句话的单词进行倒置，标点不倒置。比如 I like beijing。经过倒置后变为：beijing. like I

三步翻转法

代码实现：

#include<stdio.h>
void reverse(char* left, char* right)
{
	while (left<right)
	{
		char tmp = 0;
		tmp = *left;
		*left = *right;
		*right = tmp;
		left++;
		right--;
	}
}

int main()
{
	char arr[20];
	gets(arr);
	int len = strlen(arr);
	reverse(arr, arr + len - 1);
	char* start = arr;
	while (*start)
	{
		char* end = start;
		while (*end != ' '&&*end!='\0')
		{
			end++;
		}
		reverse(start, end - 1);
		if (*end == ' ')
			start = end + 1;//跳过空格
		else
			start = end;//
	}	
	return 0;
}

二、字符串左旋

左旋字符串中的k个字符
ABCD左旋一个字符后BCDA
ABCD左旋两个字符后CDAB

常规写法

一看到题目，我们想到的便是暴力移位法:每次旋转单个字符，一位一位往前挪。

void rotake(char* a, int sz)
{
	int k,i,j;
	int left, right;
	char house;
	scanf("%d", &k);
	for (i = 0; i < k; i++)//每次旋转一个字符
	{
		house = a[0];
		for (j = 0; j < sz - 1; j++)
		{
			a[j] = a[j+1];//往前挪
		}
		a[j] = house;
	}
	printf("%s", a);
}
 
 
int main()
{
	char a[20] = "abcd";
	int sz = strlen(a);
	rotake(a,sz);
	return 0;
}

三步翻转法

#include<string.h>
#include<stdio.h>
#include<assert.h>
void reverse(char* left, char* right)
{
	assert(left && right);
	while (left < right)
	{
		char t = *left;
		*left = *right;
		*right = t;
		left++;
		right--;
	}
}

void rotake(char* str, int k)
{
	assert(str);
	int n = strlen(str);
	reverse(str, str + k - 1);
	reverse(str + k, str + n - 1);
	reverse(str, str + n - 1);
}
int main()
{
	char arr[10] = { "ABCDEF" };
	int k = 2;
	rotake(arr,k);
	return 0;
}

显然，使用三步翻转法可以提高我们解题的效率。

三、判断是否为旋转字符串

判断一个字符串是否为另外一个字符串旋转后的字符串
s1=AABCD和s2 = BCDAA，返回1 - 是
s1=abcd和s2=ACBD，返回0.

int rotake(char* str1, char* str2)
{
	int i = 0;
	int n = strlen(str1);
	for (i = 0; i < n ; i++)
	{
		char t = *str1;
		int j = 0;
		for (j = 0; j < n - 1; j++)
		{
			*(str1 + j) = *(str1 + j + 1);
		}
		*(str1 + n - 1) = t;
		if (strcmp(str1, str2) == 0)
		{
			return 1;
		}
	}
	return 0;
}
int main()
{
	char arr1[] = "AABCD";
	char arr2[] = "BCDAA";
	int ret = rotake(arr1,arr2);
	if (ret == 1)
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}
	return 0;
}

巧用函数法

int rotake(char* str1, char* str2)
{
	if (strlen(str1) != strlen(str2))
	{
		return 0;
	}
	int len = strlen(str1);
	strncat(str1, str1, len);//自己复制自己不能使用strcat函数
	char* ret = strstr(str1, str2);
	return ret != NULL;
}

int main()
{
	char arr1[] = "AABCD";
	char arr2[] = "BCDAA";
	int ret = rotake(arr1,arr2);
	if (ret == 1)
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}
	return 0;
}

strcat( )函数： dest 与 src 所指的内存空间不能重叠，且 dest 要有足够的空间来容纳要复制的字符串。

strcat() 会将参数 src 字符串复制到参数 dest 所指的字符串尾部；dest 最后的结束字符\0 会被覆盖掉，并在连接后的字符串的尾部再增加一个 NULL。

由于 dest 与 src 所指的内存空间重叠，所以字符串被修改了，不会再有\0出现，因此会导致出错。

四、写在最后

分析：

1. X->X^T，即AB->BA
2. Y->Y^T，即CDEF->FEDC
3. (X^TY ^T) ^T=YX，即BAFEDC->CDEFAB