說起字串的左旋和右旋問題，想必大家都不陌生，這是一個在初學C語言過程中經常遇到的一個問題，解題的思路可以說很多，每一個人的看待問題的角度都不同，所以就可以得到不同的解題思路。下面我就列舉幾種方法：

先從最容易想到的說起：

以字串abcdef為例，若是左旋問題，首先我們可以拿出首個字元a，將其與後面的每一個字元交換一次，得到新的字串bcdefa，然後進行交換得到cdefab，迴圈執行，一直到次數等於你給定的次數。（右旋與此類似）

程式碼如下所示：

void LRevolve_Words(char *Pword, int  k, int len)            //左旋，k為指定的左旋字元的個數
{
	int i = len;                                         
	char temp;
	while (k--)
	{
		for ( i = 0; i < len - 1 ; i++)              //依次交換
		{
			temp = *(Pword + i);
			*(Pword + i) = *(Pword + i + 1);
			*(Pword + i + 1) = temp;
		}
	}
}
 

void RRevolve_Words(char *Pword, int  k, int len)               //右旋
{
	int i = len;
	char temp;
	while (k--)
	{
		for ( i = len ; i > 1 ; i--)
		{
			temp = *(Pword + i - 1);
			*(Pword + i - 1) = *(Pword +  i - 2);
			*(Pword + i - 2) = temp;
		}
	}
}

       上面的方法是最簡單的，也容易想到，實現起來簡單，程式碼容易理解，但是最主要的缺點就是效率不高，如果不考慮時間和空間的限制，假設移動的位為k，則要迴圈k次，每次迴圈移動1位，這樣的空間複雜度是0(1)，時間複雜度是0(n*k)，如果k大於n，則0(n^2)。因此，如果K>N，右移K - N之後的陣列序列跟右移K位的結果是一樣的。

       下面介紹一種比較巧妙地方法：（個人認為也是最好的方法）

採用先部分再整體的方法（或者先整體再部分，效果差不多）：具體實現是先反轉前k個字元，然後再反轉後n - k個字元，最後再反轉整個字串。這種方法比上面一種方法高效。時間複雜度是0(n)，空間複雜度為0(1)。

這種方法也叫三步反轉法。（以左旋為例，右旋與之類似）

#include<stdio.h>
#include <string.h>
#include<assert.h>
#define Max_Words 20
void Reverse_String(char * Pword, char * qword)
{
	char *pa = Pword;
	char *pb = qword;
	char temp;
	assert(Pword);
	assert(qword);
	while (pa<pb)
	{
		temp = *pa;
		*pa = *pb;
		*pb = temp;
		pa++;
		pb--;
	}
}
int main()
{
	char arr[Max_Words];
	int len = 0;
	int k = 0;
	char *pStart = NULL;
	char *pEnd = NULL;
	printf("請輸入您要旋轉的字串內容\n");
	scanf("%s", arr);
	len = strlen(arr) - 1;
	printf("請輸入您要旋轉的字元個數\n");
	scanf("%d", &k);
	pStart = &arr[0];
	pEnd = arr + len;
	Reverse_String(pStart, pStart + k - 1);             //把要左旋的k個字元先逆序翻轉
	Reverse_String(pStart + k, pEnd);                    //把k+1後的字元逆序翻轉
	Reverse_String(pStart, pEnd);                          //整個字串逆序翻轉        
	printf("旋轉之後的字串為：%s\n", arr);
	return 0;
}
 

        接著再介紹一種不是一下子可以想到的方法。就是用遞迴，當然不是說這方法很難，只是我們不經常用這方法，或者說如果不提醒你，你是無法一下子想到的。（一般會提示你請用遞迴方法解決）

當然遞迴也有不同的遞迴方式：

方式一：

        每次向右移動K位，最後遞迴，把一個規模為N的問題化解為規模為M(M<N)的問題。

       舉例來說，設字串總長度為L，左側要旋轉的部分長度為s1，那麼當從左向右迴圈交換長度為s1的小段，直到最後，由於剩餘的部分長度為s2(s2==L%s1)而不能直接交換。

該問題可以遞迴轉化成規模為s1+s2的，方向相反(從右向左)的同一個問題。隨著遞迴的進行，左右反覆迴盪，直到某一次滿足條件L%s1==0而交換結束。可以說是第一種方法更好地展示。

方式二：

        先說左旋，每次都把一個元素拿出來，然後將把一個元素先拿出來，放在一個臨時變數temp之中，並把這個元素改成‘\0’，然後進行遞迴，直到達到指定的次數，遞迴結束，之後進行遞迴的返回，返回後依次拿出之前儲存的temp賦值給最後面元素之後的一個空間，（當然這裡需要額外的空間，定義的陣列要比字串內容大）。

void LRevolve_Words(char *Pword , int  k , int len)             //len為陣列內容的大小
{
	char temp;
	assert(Pword);
	if (k)
	{
		 temp = *Pword;
		 *Pword = '\0';                                 //將首字元改成‘\0’
		 LRevolve_Words(Pword + 1, k - 1 , len);
		*(Pword + len  ) = temp;
	}
	*(Pword + len + k) = '\0';
}

void RRevolve_Words(char *Pword , int  k , int len)
{
    char temp;
    int i;
    assert(Pword);
    if (k)
    {
        temp = Pword[len - 1];
        for ( i = 0; i < len ; i++)
        {
            Pword[len - i  ] = Pword[len - i - 1];
        }
        Pword[len] = '\0';
         RRevolve_Words(Pword + 1, k - 1 , len - 1);
        *Pword  = temp;                                          
    } 
}