左旋转字符串LeftRotateString -- 翻转单词顺序

源自：http://blog.csdn.net/v_JULY_v/article/details/6322882

题目描述：

定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。
如把字符串abcdef左旋转2位得到字符串cdefab。
请实现字符串左旋转的函数，要求对长度为n的字符串操作的时间复杂度为O(n)，空间复杂度为O(1)。

分析：

我们先试验简单的办法，可以每次将数组中的元素右移一位，循环K次。
abcd1234→4abcd123→34abcd12→234abcd1→1234abcd。
RightShift(int* arr, int N, int K)
{
     while(K--)
     {
          int t = arr[N - 1];
          for(int i = N - 1; i > 0; i --)
               arr[i] = arr[i - 1];
          arr[0] = t;
     }
}

虽然这个算法可以实现数组的循环右移，但是算法复杂度为O（K * N），不符合题目的要求，要继续探索。

假如数组为abcd1234，循环右移4位的话，我们希望到达的状态是1234abcd。
不妨设K是一个非负的整数，当K为负整数的时候，右移K位，相当于左移（-K）位。
左移和

解法一：
大家开始可能会有这样的潜在假设，K<N。事实上，很多时候也的确是这样的。但严格来说，我们不能用这样的“惯性思维”来思考问题。
尤其在编程的时候，全面地考虑问题是很重要的，K可能是一个远大于N的整数，在这个时候，上面的解法是需要改进的。
仔细观察循环右移的特点，不难发现：每个元素右移N位后都会回到右移在本质上是一样的。自己的位置上。因此，如果K > N，右移K-N之后的数组序列跟右移K位的结果是一样的。

进而可得出一条通用的规律：
右移K位之后的情形，跟右移K’= K % N位之后的情形一样，如代码清单2-34所示。
//代码清单2-34
RightShift(int* arr, int N, int K)
{
     K %= N;
     while(K--)
     {
          int t = arr[N - 1];
          for(int i = N - 1; i > 0; i --)
               arr[i] = arr[i - 1];
          arr[0] = t;
     }
}
可见，增加考虑循环右移的特点之后，算法复杂度降为O（N^２），这跟K无关，与题目的要求又接近了一步。但时间复杂度还不够低，接下来让我们继续挖掘循环右移前后，数组之间的关联。

解法二：
假设原数组序列为abcd1234，要求变换成的数组序列为1234abcd，即循环右移了4位。比较之后，不难看出，其中有两段的顺序是不变的：1234和abcd，可把这两段看成两个整体。右移K位的过程就是把数组的两部分交换一下。
变换的过程通过以下步骤完成：
 逆序排列abcd：abcd1234 → dcba1234；
 逆序排列1234：dcba1234 → dcba4321；
 全部逆序：dcba4321 → 1234abcd。
伪代码可以参考清单2-35。
//代码清单2-35
Reverse(int* arr, int b, int e)
{
     for(; b < e; b++, e--)
     {
          int temp = arr[e];
          arr[e] = arr[b];
          arr[b] = temp;
     }
}

RightShift(int* arr, int N, int k)
{
     K %= N;
     Reverse(arr, 0, N – K - 1);
     Reverse(arr, N - K, N - 1);
     Reverse(arr, 0, N - 1);
}

这样，我们就可以在线性时间内实现右移操作了。

本章里我们的做法是：
1、三次翻转，直接线性
2、两个指针逐步翻转，线性
3、stl的rotate算法，线性

就拿abcdef 这个例子来说

1、首先分为俩部分，X:abc，Y:def；
2、X->X^T，abc->cba， Y->Y^T，def->fed。
3、(X^TY^T)^T=YX，cbafed->defabc，即整个翻转。

1.  
2. #include <stdio.h>  
3. #include <string.h>  
4.   
5. char * invert(char *start, char *end)  
6. {     
7.     char tmp, *ptmp = start;      
8.     while (start != NULL && end != NULL && start < end)    
9.     {     
10.         tmp = *start;     
11.         *start = *end;        
12.         *end = tmp;       
13.         start ++;     
14.         end --;   
15.     }  
16.     return ptmp;  
17. }  
18.   
19. char *left(char *s, int pos)   //pos为要旋转的字符个数，或长度，下面主函数测试中，pos=3。  
20. {  
21.     int len = strlen(s);  
22.     invert(s, s + (pos - 1));  //如上，X->X^T，即 abc->cba  
23.     invert(s + pos, s + (len - 1)); //如上，Y->Y^T，即 def->fed  
24.     invert(s, s + (len - 1));  //如上，整个翻转，(X^TY^T)^T=YX，即 cbafed->defabc。  
25.     return s;  
26. }  
27.   
28. int main()  
29. {     
30.     char s[] = "abcdefghij";      
31.     puts(left(s, 3));  
32.     return 0;  
33. }  

给出一段c实现的代码。
然后，我们可以看到c的高效与简洁。

1.  
2. #include <cstdio>  
3. #include <cstring>  
4.   
5. void rotate(char *start, char *end)  
6. {  
7.     while(start != NULL && end !=NULL && start<end)  
8.     {  
9.         char temp=*start;  
10.         *start=*end;  
11.         *end=temp;  
12.         start++;  
13.         end--;  
14.     }  
15.       
16. }  
17.   
18. void leftrotate(char *p,int m)  
19. {  
20.     if(p==NULL)  
21.         return ;  
22.     int len=strlen(p);  
23.     if(m>0&&m<=len)  
24.     {  
25.         char *xfirst,*xend;  
26.         char *yfirst,*yend;  
27.         xfirst=p;  
28.         xend=p+m-1;  
29.         yfirst=p+m;  
30.         yend=p+len-1;  
31.         rotate(xfirst,xend);  
32.         rotate(yfirst,yend);  
33.         rotate(p,p+len-1);  
34.     }  
35. }  
36.   
37. int main(void)  
38. {     
39.     char str[]="abcdefghij";  
40.     leftrotate(str,3);  
41.     printf("%s/n",str);  
42.     return 0;  
43. }  

方法二：两指针逐步翻转

abc defghi，要abc移动至最后
abc defghi->def abcghi->def ghiabc

定义俩指针，p1指向ch[0]，p2指向ch[m]；
一下过程循环m次，交换p1和p2所指元素，然后p1++, p2++；。

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

整个过程，看起来，就是abc 一步一步 向后移动
abc defghi
def abcghi
def ghi abc  
  //最后的 复杂度是O（m+n）  

针对上述过程给出的图解：

如果是要左旋十个元素的序列：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 

 下面，再针对上述过程，画个图清晰说明下，如下所示：

  ok，咱们来好好彻底总结一下此思路二：（就4点，请仔细阅读）：

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++；

代码编写如下： 

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4.   
5. void rotate(string &str, int m)  
6. {  
7.       
8.     if (str.length() == 0 || m <= 0)  
9.         return;  
10.       
11.     int n = str.length();  
12.       
13.     if (m % n <= 0)  
14.         return;  
15.       
16.     int p1 = 0, p2 = m;  
17.     int k = (n - m) - n % m;  
18.       
19.     // 交换p1，p2指向的元素，然后移动p1，p2  
20.     while (k --)   
21.     {  
22.         swap(str[p1], str[p2]);  
23.         p1++;  
24.         p2++;  
25.     }  
26.       
27.     // 重点，都在下述几行。  
28.     // 处理尾部，r为尾部左移次数  
29.     int r = n - p2;  
30.     while (r--)  
31.     {  
32.         int i = p2;  
33.         while (i > p1)  
34.         {  
35.             swap(str[i], str[i-1]);  
36.             i--;  
37.         }  
38.         p2++;  
39.         p1++;  
40.     }  
41.     //比如一个例子，abcdefghijk  
42.     //                    p1    p2  
43.     //当执行到这里时，defghi a b c j k  
44.     //p2+m出界 了，  
45.     //r=n-p2=2，所以以下过程，要执行循环俩次。  
46.       
47.     //第一次：j 步步前移，abcjk->abjck->ajbck->jabck  
48.     //然后，p1++，p2++，p1指a，p2指k。  
49.     //               p1    p2  
50.     //第二次：defghi j a b c k  
51.     //同理，此后，k步步前移，abck->abkc->akbc->kabc。  
52. }  
53.   
54. int main()     
55. {     
56.     string ch="abcdefghijk";     
57.     rotate(ch,3);     
58.     cout<<ch<<endl;     
59.     return 0;        
60. }    

   方法二：

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)需要循环左移一定次数（而后的具体操作步骤已在下述程序的注释中已详细给出）。

    根据方案二，不难写出下述代码（已测试正确）：

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4.   
5. void rotate(string &str, int m)  
6. {  
7.     if (str.length() == 0 || m < 0)  
8.         return;  
9.   
10.     //初始化p1，p2  
11.     int p1 = 0, p2 = m;     
12.     int n = str.length();  
13.   
14.     // 处理m大于n  
15.     if (m % n == 0)  
16.         return;  
17.       
18.     // 循环直至p2到达字符串末尾  
19.     while(true)  
20.     {    
21.         swap(str[p1], str[p2]);  
22.         p1++;  
23.         if (p2 < n - 1)  
24.             p2++;  
25.         else  
26.             break;  
27.     }  
28.       
29.     // 处理尾部，r为尾部循环左移次数  
30.     int r = m - n % m;  // r = 1.  
31.     while (r--)  //外循环执行一次  
32.     {  
33.         int i = p1;  
34.         char temp = str[p1];  
35.         while (i < p2)  //内循环执行俩次  
36.         {  
37.             str[i] = str[i+1];  
38.             i++;  
39.         }     
40.         str[p2] = temp;  
41.     }  
42.     //举一个例子  
43.     //abcdefghijk  
44.     //当执行到这里的时候，defghiabcjk  
45.     //      p1    p2  
46.     //defghi a b c j k，a 与 j交换，jbcak，然后，p1++，p2++  
47.     //        p1    p2  
48.     //       j b c a k，b 与 k交换，jkcab，然后，p1++，p2不动，  
49.       
50.     //r = m - n % m= 3-11%3=1，即循环移位1次。  
51.     //          p1  p2  
52.     //       j k c a b  
53.     //p1所指元素c实现保存在temp里，  
54.     //然后执行此条语句：str[i] = str[i+1]; 即a跑到c的位置处，a_b  
55.     //i++，再次执行：str[i] = str[i+1]，ab_  
56.     //最后，保存好的c 填入，为abc，所以，最终序列为defghi jk abc。  
57. }  
58.   
59. int main()  
60. {  
61.     string ch="abcdefghijk";  
62.     rotate(ch,3);  
63.     cout<<ch<<endl;  
64.     return 0;     
65. }  

注意：上文中都是假设m<n，且如果令m=m%n，这样m允许大于n。另外，各位要记得处理指针为空的情况。      

1.  */  
2. #include<iostream>  
3. #include<string>  
4. #define positiveMod(m,n) ((m) % (n) + (n)) % (n)  
5.   
6. /* 
7.  *左旋字符串str，m为负数时表示右旋abs（m）个字母 
8.  */  
9. void rotate(std::string &str, int m) {  
10.     if (str.length() == 0)  
11.         return;  
12.     int n = str.length();  
13.     //处理大于str长度及m为负数的情况,positiveMod可以取得m为负数时对n取余得到正数  
14.     m = positiveMod(m,n);  
15.     if (m == 0)  
16.         return;  
17.     //    if (m % n <= 0)  
18.     //        return;  
19.     int p1 = 0, p2 = m;  
20.     int round;  
21.     //p2当前所指和之后的m-1个字母共m个字母，就可以和p2前面的m个字母交换。  
22.     while (p2 + m - 1 < n) {  
23.         round = m;  
24.         while (round--) {  
25.             std::swap(str[p1], str[p2]);  
26.             p1++;  
27.             p2++;  
28.         }  
29.     }  
30.     //剩下的不足m个字母逐个交换  
31.     int r = n - p2;  
32.     while (r--) {  
33.         int i = p2;  
34.         while (i > p1) {  
35.             std::swap(str[i], str[i - 1]);  
36.             i--;  
37.         }  
38.         p2++;  
39.         p1++;  
40.     }  
41. }  
42.   
43. //测试  
44. int main(int argc, char **argv) {  
45.     //    std::cout << ((-15) % 7 + 7) % 7 << std::endl;  
46.     //    std::cout << (-15) % 7 << std::endl;  
47.     std::string ch = "abcdefg";  
48.     int len = ch.length();  
49.     for (int m = -2 * len; m <= len * 2; m++) {  
50.         //由于传给rotate的是string的引用，所以这里每次调用都用了一个新的字符串  
51.         std::string s = "abcdefg";  
52.         rotate(s, m);  
53.         std::cout << positiveMod(m,len) << ": " << s << std::endl;  
54.     }  
55.    
56.     return 0;  
57. }  

方法三：通过递归转换，缩小问题之规模

把一个规模为N的问题化解为规模为M(M<N)的问题。
    举例来说，设字符串总长度为L，左侧要旋转的部分长度为s1，那么当从左向右循环交换长度为s1的小段，直到最后，由于剩余的部分长度为s2(s2==L%s1)而不能直接交换。

    该问题可以递归转化成规模为s1+s2的，方向相反(从右向左)的同一个问题。随着递归的进行，左右反复回荡，直到某一次满足条件L%s1==0而交换结束。

设原始问题为：将“123abcdefg”左旋转为“abcdefg123”，即总长度为10，旋转部("123")长度为3的左旋转。按照思路二的运算，演变过程为“123abcdefg”->"abc123defg"->"abcdef123g"。这时，"123"无法和"g"作对调，该问题递归转化为：将“123g”右旋转为"g123"，即总长度为4，旋转部("g")长度为1的右旋转。

举个具体事例说明，如下：

1、对于字符串abc def ghi gk，

将abc右移到def ghi gk后面，此时n = 11，m = 3，m’ = n % m = 2;

abc def ghi gk -> def ghi abc gk

2、问题变成gk左移到abc前面，此时n = m’ + m = 5，m = 2，m’ = n % m 1;

abc gk -> a gk bc

3、问题变成a右移到gk后面，此时n = m’ + m = 3，m = 1，m’ = n % m = 0;

a gk bc-> gk a bc。 由于此刻，n % m = 0，满足结束条件，返回结果。

    即从左至右，后从右至左，再从左至右，如此反反复复，直到满足条件，返回退出。

代码如下，已测试正确（有待优化）：

1. #include <iostream>  
2. #include <string>
3. using namespace std;  
4.   
5. void rotate(string &str, int n, int m, int head, int tail, bool flag)  
6. {  
7.     //n 待处理部分的字符串长度，m：待处理部分的旋转长度  
8.     //head：待处理部分的头指针，tail：待处理部分的尾指针  
9.     //flag = true进行左旋，flag = false进行右旋  
10.       
11.     // 返回条件  
12.     if (head == tail || m <= 0)  
13.         return;  
14.       
15.     if (flag == true)  
16.     {  
17.         int p1 = head;  
18.         int p2 = head + m;  //初始化p1，p2  
19.           
20.         //1、左旋：对于字符串abc def ghi gk，  
21.         //将abc右移到def ghi gk后面，此时n = 11，m = 3，m’ = n % m = 2;  
22.         //abc def ghi gk -> def ghi abc gk  
23.         //（相信，经过上文中那么多繁杂的叙述，此类的转换过程，你应该是了如指掌了。）  
24.           
25.         int k = (n - m) - n % m;   //p1，p2移动距离，向右移六步  
26.   
27.         /*--------------------- 
28.         解释下上面的k = (n - m) - n % m的由来： 
29.         yansha： 
30.         以p2为移动的参照系： 
31.         n-m 是开始时p2到末尾的长度，n%m是尾巴长度 
32.         (n-m)-n%m就是p2移动的距离 
33.         比如 abc def efg hi 
34.         开始时p2->d,那么n-m 为def efg hi的长度8， 
35.         n%m 为尾巴hi的长度2， 
36.         因为我知道abc要移动到hi的前面，所以移动长度是 
37.         (n-m)-n%m = 8-2 = 6。 
38.         */  
39.           
40.         for (int i = 0; i < k; i++, p1++, p2++)  
41.             swap(str[p1], str[p2]);  
42.           
43.         rotate(str, n - k, n % m, p1, tail, false);  //flag标志变为false，结束左旋，下面，进入右旋  
44.     }  
45.     else  
46.     {  
47.         //2、右旋：问题变成gk左移到abc前面，此时n = m’ + m = 5，m = 2，m’ = n % m 1;  
48.         //abc gk -> a gk bc  
49.           
50.         int p1 = tail;  
51.         int p2 = tail - m;  
52.           
53.         // p1，p2移动距离，向左移俩步  
54.         int k = (n - m) - n % m;  
55.           
56.         for (int i = 0; i < k; i++, p1--, p2--)  
57.             swap(str[p1], str[p2]);  
58.           
59.         rotate(str, n - k, n % m, head, p1, true);  //再次进入上面的左旋部分，  
60.         //3、左旋：问题变成a右移到gk后面，此时n = m’ + m = 3，m = 1，m’ = n % m = 0;  
61.         //a gk bc-> gk a bc。 由于此刻，n % m = 0，满足结束条件，返回结果。  
62.   
63.     }  
64. }  
65.   
66. int main()  
67. {  
68.     int i=3;  
69.     string str = "abcdefghijk";  
70.     int len = str.length();  
71.     rotate(str, len, i % len, 0, len - 1, true);  
72.     cout << str.c_str() << endl;   //转化成字符数组的形式输出  
73.     return 0;  
74. }  

     另一个类似的问题：翻转单词顺序

题目描述：

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。

句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。
例如输入“I am a student”，则输出“student. a am I”。

思路：对于整个句子，先做一次翻转Reverse()，可得到：tneduts a ma i

所有字符颠倒过来，在对每一个单词做一次翻转ReverseSentence()，即可得到：student a am i

char* ReverseSentence(char *pData)
{
    if(pData == NULL)
        return NULL;

    char *pBegin = pData;

    char *pEnd = pData;
    while(*pEnd != '\0')
        pEnd ++;
    pEnd--;

    // 翻转整个句子
    Reverse(pBegin, pEnd);

    // 翻转句子中的每个单词
    pBegin = pEnd = pData;
    while(*pBegin != '\0')
    {
        if(*pBegin == ' ')
        {
            pBegin ++;
            pEnd ++;
        }
        else if(*pEnd == ' ' || *pEnd == '\0')
        {
            Reverse(pBegin, --pEnd);
            pBegin = ++pEnd;
        }
        else
        {
            pEnd ++;
        }
    }

    return pData;
}

void Reverse(char *pBegin, char *pEnd)
{//翻转
	if (pBegin != NULL && pEnd != NULL)
		return ;
	while (pBegin < pEnd)
	{
		char temp = *pBegin;
		*pBegin = *pEnd;
		*pEnd = temp;

		pBegin++;
		pEnd--;
	}
}