每天学习一算法系列(定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部)

Posted zhangtian6691844

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了每天学习一算法系列(定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部)相关的知识，希望对你有一定的参考价值。

这几天一直在看了July写了【横空出世，席卷互联网 [评微软等公司数据结构+算法面试100题】，里面的好多算法都很不错，所以决定把看过掌握地并亲自试验一遍没有问题后再写到自己的博客中，当然算法的思想及实现都会注明来自何方。

文章来自：http://blog.csdn.net/v_JULY_v/archive/2011/04/14/6322882.aspx

算法一：左旋转字符串

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

 

思路一：
以下的4点文字分析，引自网友zhedahht（http://zhedahht.blog.163.com/blog/#m）。
分析：
    1、如果不考虑时间和空间复杂度的限制，最简单的方法莫过于把这道题看成是把字符串分成前后两部分，通过旋转操作把这两个部分交换位置。
    2、于是我们可以新开辟一块长度为n+1的辅助空间，把原字符串后半部分拷贝到新空间的前半部分，在把原字符串的前半部分拷贝到新空间的后半部分。不难看出，这种思路的时间复杂度是O(n)，需要的辅助空间也是O(n)。
    3、因此，我们另寻思路，咱们试着把字符串看成有两段组成的，记为XY。左旋转相当于要把字符串XY变成YX。
我们先在字符串上定义一种翻转的操作，即翻转字符串中字符的先后顺序：把X翻转后记为XT,显然有(XT)T=X。
我们首先对X和Y两段分别进行翻转操作，这样就能得到XTYT。
接着再对XTYT进行翻转操作，得到(XTYT)T=(YT)T(XT)T=YX。正好是我们期待的结果。
    4、分析到这里我们再回到原来的题目：我们要做的仅仅是把字符串分成两段，
第一段为前面m个字符，其余的字符分到第二段。再定义一个翻转字符串的函数，按照前面的步骤翻转三次就行了。时间复杂度和空间复杂度都合乎要求。

[c-sharp] view plain copy print ?
  1. // 字符串旋转算法.cpp : Defines the entry point for the console application.  
  2. //copyright@ yiyibupt && July  
  3. //已测试正确，yuucyf update，2011.04.20.  
  4. #include "stdafx.h"  
  5. #include <cstdio>  
  6. #include <cstring>  
  7.   
  8. void Rotate(char *pszStart, char *pszEnd)  
  9.   
  10.     while(pszStart != NULL && pszEnd != NULL && pszStart < pszEnd)  
  11.       
  12.         char cTemp = *pszStart;  
  13.         *pszStart  =*pszEnd;  
  14.         *pszEnd = cTemp;  
  15.   
  16.         pszStart++;  
  17.         pszEnd --;  
  18.       
  19.       
  20.   
  21.   
  22. void LeftRotate(char *pszStr, int nCnt)  
  23.   
  24.     if(NULL == pszStr)  return ;  
  25.     int nLen = strlen(pszStr);  
  26.     if(nCnt > 0 && nCnt <= nLen)  
  27.       
  28.         char *pxFirst = NULL, *pxEnd = NULL;  
  29.         char *pyFirst = NULL, *pyEnd = NULL;  
  30.   
  31.         pxFirst = pszStr;  
  32.         pxEnd = pszStr + nCnt - 1;  
  33.         pyFirst = pszStr + nCnt;  
  34.         pyEnd = pszStr + nLen - 1;  
  35.   
  36.         Rotate(pxFirst, pxEnd);  
  37.         Rotate(pyFirst ,pyEnd);  
  38.         Rotate(pszStr, pszStr + nLen - 1);  
  39.       
  40.   
  41.   
  42.   
  43. int _tmain(int argc, _TCHAR* argv[])  
  44.   
  45.     char aszStr[] = "Modified by yuucyf";  
  46.   
  47.     LeftRotate(aszStr, 8);  
  48.   
  49.     printf("%s/n",aszStr);  
  50.   
  51.     return 0;  
  52.   

 

 

 flyinghearts：
      ① 动态分配一个同样长度的数组，将数据复制到该数组并改变次序，再复制回原数组。（最最普通的方法）
      ② 利用ba=(br)^T(ar)^T=(arbr)^T，通过三次反转字符串。（即上述思路一，首先对序列前部分逆序，再对序列后部分逆序，再对整个序列全部逆序）
      ③ 分组交换（尽可能使数组的前面连续几个数为所要结果）：
      若a长度大于b，将ab分成a0a1b，交换a0和b，得ba1a0，只需再交换a1 和a0。
      若a长度小于b，将ab分成ab0b1，交换a和b0，得b0ab1，只需再交换a 和b0。
      通过不断将数组划分，和交换，直到不能再划分为止。分组过程与求最大公约数很相似。
      ④ 所有序号为 (i+t*k) % n (i为指定整数，t为任意整数)，会构成一个循环链（共有gcd(n,k)个，gcd为n、k的最大公约数），每个循环链上的元素只要移动一个位置即可，总共交换了n次。

 

上面所说的是第二种方法，其中第一种是最普通的，这里不讲，接的讨论第三种方法：
思路二：

就是对m和n求最大公约数，然后将数组分为gcd(m,n)组分别进行循环移位。 
代码如下：

[cpp] view plain copy print ?
  1. void Rotate2(string &str, int nRCnt)   
  2.    
  3.     int nLen = str.length();   
  4.     int nNumOfGroup = Gcd(nLen, nRCnt);   
  5.     int nElemInSub = nLen / nNumOfGroup;    
  6.   
  7.     // 整个数组分为nNumOfGroup组，每组有nElemInSub个元素  
  8.     int i = 0, j = 0;  
  9.     for(i = 0; i < nNumOfGroup; i++)   
  10.        
  11.         char cTemp = str[i];   
  12.   
  13.         // 每组内循环nElemInSub-1次  
  14.         for (j = 0; j < nElemInSub - 1; j++)  
  15.             str[(i + j * nRCnt) % nLen] = str[(i + (j + 1) * nRCnt) % nLen];  
  16.   
  17.         str[(i + j * nRCnt) % nLen] = cTemp;   
  18.        
  19.   
  20.   
  21. int _tmain(int argc, _TCHAR* argv[])  
  22.   
  23.     //char aszStr[] = "Modified by yuucyf";  
  24.     //LeftRotate(aszStr, 8);  
  25.     //printf("%s/n",aszStr);  
  26.   
  27.     string strStr = "abcdefg";  
  28.     Rotate2(strStr, 3);  
  29.     printf("%s/n",strStr.c_str());  
  30.   
  31.     return 0;  
  32.   

 

思路三：

[cpp] view plain copy print ?
  1. //对上述方案4的改写  
  2. //④ 所有序号为 (i+t*k) % n (i为指定整数，t为任意整数)，....  
  3. //copyright@ hplonline && July 2011.04.18。  
  4. void my_rotate(int *begin, int *mid, int *end)  
  5.     int n = end - begin ;  
  6.     int k = mid - begin ;  
  7.     int d = __gcd(n, k) ;  
  8.     int i, j ;  
  9.     // (i + k * j) % n % d == i % d  
  10.     for ( i = 0 ; i < d ; i ++ )  
  11.       
  12.         int tmp = begin[i] ;  
  13.         int last = i ;  
  14.         for ( j = (i + k) % n ; j != i ; j++ )  
  15.           
  16.             begin[last] = begin[j] ;      
  17.             last = j ;  
  18.               
  19.         begin[last] = tmp ;  
  20.       
  21.   
  22.   
  23. //前面的代码有问题，多谢zdbill指出.  
  24. //下面贴出纠正后的程序.  
  25.   
  26. void my_rotate(char *begin, char *mid, char *end)  
  27.      
  28.     int n = end - begin;     
  29.     int k = mid - begin;     
  30.     int d = gcd(n, k);     
  31.     int i, j;     
  32.     for (i = 0; i < d; i ++)     
  33.          
  34.         int tmp = begin[i];     
  35.         int last = i;     
  36.           
  37.         //i+k为i右移k的位置，%n是当i+k>n时从左重新开始。  
  38.         for (j = (i + k) % n; j != i; j = (j + k) % n)    //多谢zdbill指正。     
  39.              
  40.             begin[last] = begin[j];         
  41.             last = j;     
  42.                  
  43.         begin[last] = tmp;     
  44.          
  45.    

以上是关于每天学习一算法系列(定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部)的主要内容，如果未能解决你的问题，请参考以下文章

算法系列——左旋字符串(剑指offer)

算法系列——左旋字符串(剑指offer)

微软100题定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 如把字符串abcdef左旋转2位得到字符串cdefab。请实现字符串左旋转的函数。

数据结构与算法面试题80道（26）

左旋转字符串

剑指offer—左旋转字符串