标签（空格分隔）： lintCode

旋转字符串

给定一个字符串和一个偏移量，根据偏移量旋转字符串(从左向右旋转)

样例

对于字符串 "abcdefg".

offset=0 => "abcdefg"
offset=1 => "gabcdef"
offset=2 => "fgabcde"
offset=3 => "efgabcd"

挑战

在数组上原地旋转，使用O(1)的额外空间

解法一: 先将所有的字符向后移动一位,然后将最后一个字符放到第一个字符上,重复过程

void rotateString01(string &str, int offset) {
        char temp;
        if (offset == 0) return;
        if (str.size() == 0)return;
        
        int len = str.size();
        offset = offset%len;
        
        for (int i = 1; i <= offset; i++) {

            //把最后一个字符保存起来
            temp = str[len - 1];
            
            //倒数第二位
            int j = len - 2;
    
            while (j >= 0) {


                str[j + 1] = str[j];

                j--;
            }
            str[0] = temp;
        }
    }

解法二:

    /*
     源:     (1) a1------------a2b1------b2;
     绕轴旋转:(2) b2------b1a2------------a1;
     从图中我们可以观察出 旋转的结果是原图关于中心点对称.
     证明:
     对于数轴上一点 x 关于任意一点 x0 对称之后的坐标 x' = x-2(x-x0)
     对于上图,又要求对称之后,要对齐中心点,因此 x' = x-2(x-x0)-2x0 = -x;
     因此,图(2)就是图(1)中心对称的结果
     
     而我们的目标结果是:(3)所示的结果
     (1) a1------------a2b1------b2;
     (2) b2------b1a2------------a1;
     (3) b1------b2a1------------a2;
     这个就简单了,(3)其实就是(2)分别对两端做中心对称.
    */
    void rotateString(string &str, int offset) {
        if (offset == 0) return;
        if (str.length() == 0)return;
        int len = str.length();
        //当offset是len的整数倍时,其实相当于没有做任何操作
        offset = offset%len;
        //(1)-->(2)
        reserve(str, 0, len - 1);
        //(2)-->(3)
        reserve(str, 0, offset - 1);
        reserve(str, offset, len - 1);
    }
    /*
     中心原点对称翻转
    */
    void reserve(string &str, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            exchange(str[i], str[j]);
        }
    }
    void exchange(char &a, char &b) {
        char tmp = a;
        a = b;
        b = tmp;
    }

解法三:抛开空间复杂度O(1),我们使用递归算法求解,做到均很时间复杂度和空间复杂度的均衡:
原理:其实我们可以将字符串看成两段:A段和B段

a1------------a2b1------b2;
不断的移动B,从左到右与A进行交换:
a1-----b1------b2a'------a2;
....
当A剩下的部分不足以和B进行交换时,我们将两者的角色交换,即,我们总是用小的一方,去交换大的一方

void rotateString02(string &str, int offset) {
        int size = str.size();
        if (size == 0) return;
        offset = offset % size;
        if (offset == 0 ) {
            return;
        }
        strExchange(str, size - offset, offset, 0, size - offset - 1);
    }

    //总是用少的那部分去和多的作交换,
    void strExchange(string &str, int sStart, int len , int tStart, int tEnd) {
        int sLen = tEnd - tStart + 1;
        //没有目标需要交换
        if (sLen == 0) return;

        if (sLen < len) { //目标字符串小源字符串,用源字符串去交换目标字符串
            strExchange(str, tStart, sLen, sStart, sStart + len-1);
            return;
        }
        //从右到左交换
        if (sStart > tStart) {
            for (int i = 0; i < len; i++) {
                exchange(str[sStart+i], str[tEnd-len+1+i]);
            }
            sStart = sStart - len;
            tEnd = tEnd - len;
            strExchange(str, sStart, len, tStart, tEnd);
        }
        else { //从做到右交换
            for (int i = 0; i < len; i++) {
                exchange(str[sStart + i], str[tStart + i]);
            }
            sStart = sStart + len;
            tStart = tStart + len;
            strExchange(str, sStart, len, tStart, tEnd);
        }
    }
    
    void exchange(char &a, char &b) {
        char tmp = a;
        a = b;
        b = tmp;
    }