题目描述：
定义字符串的左旋转操作：把字符串前面的k个字符移动到字符串的尾部。如把字符串abcdef左旋转k=2位得到字符串cdefab。请实现字符串左旋转的函数，要求对长度为n的字符串操作的时间复杂度为O(n)，空间复杂度为O(1)。
大家开始可能会有这样的潜在假设，K<N。事实上，很多时候也的确是这样的。但严格来说，我们不能用这样的“惯性思维”来思考问题。尤其在编程的时候，全面地考虑问题是很重要的，K可能是一个远大于N的整数。
仔细观察循环左移的特点，不难发现：每个元素左移N位后都会回到自己的位置上。因此，左移K位之后的情形，跟左移K’= K % N位之后的情形一样。
有三种方法可以实现线性时间内的左旋操作：
1、三次翻转，直接线性
2、两个指针逐步翻转，线性
3、stl的rotate算法，线性
1：三次翻转
将一个字符串分成两部分，X和Y两个部分，在字符串上定义反转的操作：
a、首先分为俩部分，X: abc，Y: def;
b、X->
c、
代码如下：
char *invert(char *start, char *end)
{
char tmp, *ptmp = start;
while (start != NULL && end != NULL && start < end)
{
tmp = *start;
*start = *end;
*end = tmp;
start ++;
end --;
}
return ptmp;
}
char *leftrotate(char *s, int pos) //pos为要旋转的字符个数，或长度。
{
int len = strlen(s);
invert(s, s + (pos - 1)); //即 abc->cba
invert(s + pos, s + (len - 1)); //即 def->fed
invert(s, s + (len - 1)); //即cbafed->defabc。
return s;
}
2、两个指针逐步翻转
先来看个例子，如下，
abcdefghi，若要abc移动至最后：abcdef ghi->def abc ghi->def ghi abc
设m表示左旋的字符个数，n表示字符串长度。所以可定义俩指针，p1指向ch[0]，p2指向ch[m]，交换p1和p2所指元素，然后p1++, p2++。
但是上面的例子是一种特殊情况，更普遍的情况是最后一次交换时会留有尾巴，比如如果abc def ghi j要变成def ghi j abc：
abc def ghi j -> def abc ghi j-> def ghi abc j
此时abc j就是最后的尾巴，已经不能按照前面的处理方法了，所以需要如下的步骤： def ghi abc j -> def ghi abjc-> def ghi aj bc-> def ghi j abc。
总结如下：
a、首先让p1=ch[0]，p2=ch[m]，即让p1，p2相隔m的距离；
b、判断p2+m-1是否越界，如果没有越界转到c，否则转到d
c、不断交换*p1与*p2，然后p1++，p2++，循环m次，然后转到2。
d、此时p2+m-1已经越界，在此只需处理尾巴。过程如下：
d.1 通过n-p2得到p2与尾部之间元素个数r，即我们要前移的元素个数。
d.2 以下过程执行r次：
ch[p2]<->ch[p2-1]，ch[p2-1]<->ch[p2-2]，....，ch[p1+1]<->ch[p1]；p1++；p2++；
代码如下：
void rotate(string &str, int m)
{
if (str.length() == 0 || m <= 0)
return;
int n = str.length();
if (m % n <= 0)
return;
int p1 = 0, p2 = m;
int k = n - n % m - m; //k表示尾巴之前的字符个数
// 交换p1，p2指向的元素，然后移动p1，p2
while (k --)
{
swap(str[p1], str[p2]);
p1++;
p2++;
}
// 重点，都在下述几行。处理尾巴，r为尾部左移次数
int r = n - p2;
while (r--)
{
int i = p2;
while (i > p1)
{
swap(str[i], str[i-1]);
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。
}
这里的尾巴的处理，其实可以采用递归的方法，递归的进行左旋或者右旋即可，不再赘述。
3：stl的rotate算法
考虑下面两个例子：
a: 将abcdef左旋2位，所以m=2, n=6，所以可以这样模拟：abcdef|ab
从第0位开始：0 <- 2 <- 4 <- 0(6%n == 0)，得到cbedaf。接下来从第1位开始：1 <- 3 <- 5 <- 1(7%n == 1)，得到cdefab。此时，从0到5都已经移动了一次，所以得到了最终结果。
b：将abcdefg左移2位，所以m=2, n=7，所以可以这样模拟：abcdefg|ab
从第0位开始：0 <- 2 <- 4 <- 6 <- 1(8%n == 1) <- 3 <- 5 <-0(7%n == 0)。至此，从0到6都已经移动了一次，所以得到了最终结果。
以上就是stl中的rotate算法的思想，具体描述如下：根据循环链来进行移动，所谓的循环链，就是所有序号为(j+ i*m) % n的元素构成的“环”，j为循环链的开始序号。循环链上的所有元素都移动到循环链中的前一位置。
一个循环链上共有多少个元素？从j开始，下一个元素是(j+m)%n，然后依次是(j+2m)%n, (j+3m)%n,..., (j+km)%n。所谓的循环链，就是因为链中所有序号构成了环，所以j = (j+km)%n。k就是使该等式成立的最小值。那么k等于多少，循环链上就有多少个元素。
j = (j+km)%n，意味着n|km (|表示整除)，设t = gcd(n, m)表示n和m的最大公约数，所以n = xt, m = yt，因为t是最大公约数，所以x和y互质。所以： xt|kyt -> x|ky，因为x，y互质，所以k = x = n/t。所以，循环链中的元素个数为
这样，每个循环链上的元素移动一次，所有循环链完成移动之后，也就达到了左旋的效果。
gcd是求最大公约数的算法：给定俩个正整数m，n（m>=n），求它们的最大公约数。（注意，一般要求m>=n，若m<n，则要先交换m<->n。下文，会具体解释）。
用数学定理表示即为：“定理：gcd(a,b) = gcd(b, a % b) (a>b 且a % b 不为0)”。以下，是此算法的具体流程：
a、[求余数]，令r=m%n，r为n除m所得余数（0<=r<n）；
b、[余数为0?]，若r=0，算法结束，此刻，n即为所求答案，否则，继续，转到3；
c、[重置]，置m<-n，n<-r，返回步骤1.
代码如下：
void my_rotate(char *begin, char *mid, char *end)
{
int n = end - begin; //n表示字符串长度
int k = mid - begin; //k表示左旋元素的个数
int d = gcd(n, k); //d表示循环链个数
int i, j;
for (i = 0; i < d; i ++) //i表示循环链的起始序号
{
int tmp = begin[i];
int last = i;
//j为循环链的下一个元素
for (j = (i + k) % n; j != i; j = (j +k) % n)
{
begin[last] = begin[j];
last = j;
}
begin[last] = tmp;
}
}
http://blog.csdn.net/v_JULY_v/article/details/6322882