【《程序员编程艺术》】左旋转字符串

题目链接
https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/
要求不在开辟新的空间

暴力移位法

思路

例如左移m个字符

1. 将所有元素向左移动一位 ，将原来的第一位放到最后一位
2. 将步骤1循环m次

如果字符串有n个元素，左移m位 则时间复杂度是O(m*n)

代码实现

char* leftShiftOne(char* s, int len)//一次左移
{
    char temp = s[0];
    //temp储存首元素
    int i = 0;
    for (i = 1; i < len; ++i)//每一位都左移
    {
        s[i - 1] = s[i];
    }
    s[len - 1] = temp;//将第一个元素放在最后一位
    return s;
}

char* reverseLeftWords(char* s, int m) {
    int len = strlen(s);
    while (m--)//循环m次
    {
        leftShiftOne(s, len);
    }
    return s;
}

指针翻转法

思路一

咱们先来看个例子，如下：abc defghi，若要让 abc 移动至最后的过程可以
是：abc defghi->def abcghi->def ghiabc
4
如此，我们可定义俩指针，p1 指向 ch[0]，p2 指向 ch[m]；
一下过程循环 m 次，交换 p1 和 p2 所指元素，然后 p1++, p2++；。

1. 第一步，交换 abc 和 def ，abc defghi->def abcghi
2. 第二步，交换 abc 和 ghi，def abcghi->def ghiabc

整个过程，看起来，就是 abc 一步一步 向后移动

abc defghi

def abcghi

def ghi abc
//最后的 复杂度是 O（m+n）

由上述例子九个元素的序列 abcdefghi，您已经看到，m=3 时，p2 恰好指到
了数组最后一个元素，于是，上述思路没有问题。但如果上面例子中 i 的后面
还有元素列?

即，如果是要左旋十个元素的序列：abcdefghij，ok，下面，就举这个例子，
对 abcdefghij 序列进行左旋转操作：
如果 abcdef ghij 要变成 defghij abc：
abcdef ghij

1. def abc ghij
2. def ghi abc j //接下来，j 步步前移
3. def ghi ab jc
4. def ghi a j bc
5. def ghi j abc
   下面，再针对上述过程，画个图清晰说明下，如下所示：
   
   思路

1、首先让 p1=ch[0]，p2=ch[m]，即让 p1，p2 相隔 m 的距离；

2、判断 p2+m-1 是否越界，如果没有越界转到 3，否则转到 4（abcdefgh 这
8 个字母的字符串，以 4 左旋，那么初始时 p2 指向 e，p2+4 越界了，但事实
上 p2 至 p2+m-1 是 m 个字符，可以再做一个交换）
。
3、不断交换p1 与p2，然后 p1++，p2++，循环 m 次，然后转到 2。

4、此时 p2+m-1 已经越界，在此只需处理尾巴。过程如下：
4.1 通过 n-p2 得到 p2 与尾部之间元素个数 r，即我们要前移的元素个数。
4.2 以下过程执行 r 次：ch[p2]<->ch[p2-1]，ch[p2-1]<->ch[p2-2]，…，
ch[p1+1]<->ch[p1]；p1++；p2++；

代码实现

char* reverseLeftWords(char* s, int m)
{
	int len = strlen(s);
	//求出字符串的长度

	if (len == 0 || m == 0)
	{
		return s;
	}

	if (m % len <= 0)
	{
		return s;
	}

	int p1 = 0, p2 = m;
	//p1 p2标记位置
	int k = (len - m) - len % m;
	//len-m标记到p2的位置 减去最后不够一个m的元素个数
	//求得的k就是需要循环的次数

	while (k--)//循环交换
	{
		int temp = s[p1];
		s[p1] = s[p2];
		s[p2] = temp;
		p1++;
		p2++;
	}

	int r = len - p2;
	//这里如果上面的交换部分正好完成任务
	//则r=0 不进入下面的过程
	//
	while (r--)//当所有元素都被移动后停止循环
	{
		int i = p2;
		while (i > p1)//当元素被提到p1位置之后的位置时循环结束
		{
			int temp = s[i];
			s[i] = s[i - 1];
			s[i - 1] = temp;
			i--;
		}
		p2++;
		p1++;
	}
	//比如一个例子，abcdefghijk
// p1 p2
//当执行到这里时，defghi a b c j k
//p2+m 出界 了，
//r=n-p2=2，所以以下过程，要执行循环俩次。
//第一次：j 步步前移，abcjk->abjck->ajbck->jabck
//然后，p1++，p2++，p1 指 a，p2 指 k。
// p1 p2
//第二次：defghi j a b c k
//同理，此后，k 步步前移，abck->abkc->akbc->kabc。
	return s;
}

思路二

思路二是思路一最后遇到的问题的另一种思路
def ghi abc jk
当 p1 指向 a，p2 指向 j 时，那么交换 p1 和 p2，
此时为:
def ghi jbc ak
p1++，p2++,p1 指向 b，p2 指向 k，继续上面步骤得:
def ghi jkc ab
p1++，p2 不动,p1 指向 c，p2 指向 b，p1 和 p2 之间（cab)也就是尾巴，
那么处理尾巴（cab)需要循环左移一定次数

代码实现

char* reverseLeftWords(char* s, int m)
{
	int len = strlen(s);
	if (len == 0 || m < 0)
		return s;

	//初始化 p1，p2
	int p1 = 0, p2 = m;
	int n = len;

	//处理 m 大于 n
	if (m % n == 0)
		return s;

	while (1)//循环直到p2到达字符串末尾 
	{
		int temp = s[p1];
		s[p1] = s[p2];
		s[p2] = temp;
		p1++;
		if (p2 < len - 1)
			p2++;
		else
			break;//跳出时p1++，p2不改变
	}

	int r = m - n % m;
	//循环移位的次数
	
	while (r--)
	{
		int i = p1;
		char temp = s[i];
		while (i < p2)
		{
			s[i] = s[i + 1];
			i++;
		}
		s[p2] = temp;
	}
	//p1 所指元素 c 实现保存在 temp 里，
	//然后执行此条语句：str[i] = str[i+1]; 即 a 跑到 c 的位置处，a_b
	//i++，再次执行：str[i] = str[i+1]，ab_
	//最后，保存好的 c 填入，为 abc，所以，最终序列为 defghi jk abc。
	return s;

}

三步翻转法

思路
思路非常简单

1. 将前m个字符翻转
2. 将后m-n个字符翻转
3. 将整个字符串翻转

代码实现

char* invert(char* start, char* end)
{
	char* p = start;
	//保存起始位置的地址

	while (start != NULL && end != NULL && start < end)
	{
		char temp = *start;
		*start = *end;
		*end = temp;
		//首尾互换
		start++;
		end--;
	}
	
	return p;
}
char* reverseLeftWords(char* s, int m)
{
	int len = strlen(s);
	invert(s, s + m - 1);//翻转前m个字符
	invert(s + m, s + len - 1);//翻转后len-m个字符
	invert(s, s + len - 1);//翻转整个字符串

	return s;
}