旋转字符串的三种算法

题目: 给定一个长度为n的字符串,将它向左旋转i个位置,例如,str = "abcdefg", n = 7, i = 3,则旋转后,str = "defgabc",要求空间复杂度为1。

一般,解旋转字符串这样的题目,最简单的做法即是先将前i个字符拷贝到临时空间,然后将后n - i个字符前移,最后再将临时空间中的数据拷贝到原字符串的后i个位置上。但这样做会额外浪费i个空间。现给出如下三种算法:

• 算法一:

[cpp]  view plain copy
  1. void swap(char* str, int n, int ){                                                                                                                   
  2.   
  3.     int j;  
  4.     for (j = 0; j < i; ++j) {  
  5.   
  6.         int t = str[j];  
  7.         str[j] = str[n - i + j];  
  8.         str[n - i + j] = t;  
  9.     }  
  10. }  
  11.   
  12. void rotate(char* str, int n, int i) {  
  13.       
  14.     if (0 == i || n == i)  
  15.         return;  
  16.   
  17.     int k = n - i;  
  18.     if (i < k) {  
  19.         swap(str, n, i);  
  20.         rotate(str, n - i, i);  
  21.     }  
  22.     else {  
  23.         swap(str, n, k);  
  24.         rotate(str + k, n - k, i - k);  
  25.     }  
  26. }  

• 算法二:

[cpp]  view plain copy
  1. void reverse(char*str, int n) {  
  2.   
  3.     int m = n / 2;  
  4.     int i;  
  5.     for (i = 0; i < m; ++i) {  
  6.   
  7.         int t = str[i];  
  8.         str[i] = str[ n - 1 - i];  
  9.         str[n - 1 - i] = t;  
  10.     }  
  11. }  
  12.   
  13. void rotate(char* str, int n, int i) {  
  14.   
  15.     reverse(str, i);  
  16.     reverse(str + i, n - i);  
  17.     reverse(str, n);  
  18. }  

• 算法三:

[cpp]  view plain copy
  1. int gcd(int m, int n) {   
  2.   
  3.     int k = m % n;  
  4.     if (0 == k)  
  5.         return n;  
  6.     else  
  7.         return gcd(n, k);  
  8. }  
  9.   
  10. void rotate(char* str, int n, int i) {  
  11.   
  12.     int k = gcd(n, i);  
  13.     int init;  
  14.     for (init = 0; init < k; ++init) {  
  15.           
  16.         int cur = init;  
  17.         char t = str[cur];  
  18.         int next;  
  19.         for (next = (cur + i) % n; next != init; next = (cur + i) % n) {  
  20.   
  21.             str[cur] = str[next];  
  22.             cur = next;  
  23.         }     
  24.         str[cur] = t;  
  25.     }  
  26. }  

不难看出,这三种算法的空间复杂度都是1,而时间复杂度都是n。但,算法三实际上更加巧妙,它所用时间只是前两者的一半。

(注:最近看了STL关于rotate函数的源码,发现它这三种算法都用到了,其对应的迭代器 concept 分别是 ForwardIterator, BidrectionalIterator, RandomaccessIterator,不过我觉得由于前两种算法的效率是一样的,所以实际上不需要 BidrectionalIterator 版的算法。)

参考文献

《编程珠玑》(美)本特利(Bentley,J.) 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值