【C语言】实现一个函数，可以左旋字符串中的K个字符

题目说明：

要求实现一个函数，可以左旋字符串中的K个字符；
其中：
ABCD左旋一个字符得到BCDA
ABCD左旋两个字符得到CDAB

---

解法一：

解题思路：

拿到一组字符串之后，我们首先设置一个临时变量，存放字符串中的第一个字符。
然后把字符串中的其余字符通过循环依次前移一位，最后再把临时变量的值赋给字符串的最后的一位。

以上是字符串的一次左旋，要左旋几次就可以通过循环重复以上过程几次就可以了。

图解如下所示：

程序源码：

#include<iostream>
#include<assert.h>
#include<stdio.h>
#include<Windows.h>

using namespace std;

void string_reverse(char* arr, int len){
    assert(arr);
    assert(len > 0);
    char temp;
    temp = arr[0];
    for (int i = 0; i < len - 1; ++i){
        arr[i] = arr[i + 1];
    }
    arr[len - 1] = temp;
}

void Print(char* arr, int len){
    for (int i = 0; i < len; ++i){
        cout << arr[i] << "   ";
    }
    cout << endl;
}

void test(){
    char arr[] = { 'A', 'B', 'C', 'D', '1', '2', '3', '4' };
    //这里用数组来表示字符串，如果用字符串来表示字符串会产生一个错误
    //char *arr = "ABCD1234";
    int count = 0;
    int len = 0;
    len = sizeof(arr) / sizeof(arr[0]);
    //len = strlen(arr);
    Print(arr, len);
    cout << "请输入要左旋的次数：>" << endl;
    cin >> count;
    count %= len;
    while (count--){
        string_reverse(arr, len);
    }
    Print(arr, len);
}

int main(){
    test();
    system("pause");
    return 0;
}

程序运行结果：

【注意】

如果向程序中所标注的直接用字符串来表示的话，会造成以下后果：

原因：

我们先来看一个内存分配示意图：

假如现在执行以下代码：

   int a,b,c,d;
   a=0;
   b=1;
   c=2;
   d=3;

则a的地址最高，d的地址最低，因为这是一个压栈的过程。

但是如果执行以下语句的话：

char arr[] = { 'A', 'B', 'C', 'D', '1', '2', '3', '4' };

内存分配如图所示：

这时我们可以发现数组内存放的数据的地址是依次增加的，也就是说开始的元素地址最小，结束的元素地址最大。这是为什么呢？

原来数组在申请内存的时候不是为他的元素一个个申请内存，而是一次性的把数组所需要的内存申请好，再依次存放数组元素。

而如果我们在代码中用的是以字符串的形式的话，就会造成问题了：

char *arr = "ABCD1234";

---

解法二：

解题思路：

部分逆置 + 部分逆置
整体逆置

具体思路如图所示：

程序源码：

#include<iostream>
#include<assert.h>
#include<stdio.h>
#include<Windows.h>

using namespace std;

void Print(char* arr, int len){
    for (int i = 0; i < len; ++i){
        cout << arr[i] << "   ";
    }
    cout << endl;
}

//数组的逆置
void reverse(char* start, char* end){
    assert(start);
    assert(end);
    while (start<end){
        *start ^= *end;
        *end ^= *start;
        *start ^= *end;
        start++;
        end--;
    }
}

void string_reverse(char* arr, int len,int count){
    assert(arr);
    assert(len > 0);
    assert(count > 0);
    cout << "逆置前半段" << endl;
    reverse(arr, arr + count - 1);
    Print(arr, len);
    cout << "逆置后半段" << endl;
    reverse(arr + count, arr + len - 1);
    Print(arr, len);
    cout << "整体逆置" << endl;
    reverse(arr, arr + len - 1);
    Print(arr, len);
}

void test(){
    char arr[] = { 'A', 'B', 'C', 'D', '1', '2', '3', '4' };
    int count = 0;
    int len = 0;
    len = sizeof(arr) / sizeof(arr[0]);
    cout << "请输入要左旋的次数：>" << endl;
    cin >> count;
    count %= len;
    string_reverse(arr, len, count);
}

int main(){
    test();
    system("pause");
    return 0;
}

程序运行结果：

---

解法三：

解题思路：

首先把要逆置的字符串连接成双倍字符串；
然后从双倍字符的第count位开始（count是要逆转的K个字符），到第count + len结束（len是字符串长度）；
这一段就是逆转后的字符串了；
示意图如下所示：

程序源码：

#include<iostream>
#include<assert.h>
#include<stdio.h>
#include<Windows.h>

using namespace std;

void Print(char* arr, int len){
    for (int i = 0; i < len; ++i){
        cout << arr[i] << "   ";
    }
    cout << endl;
}

void string_reverse(char* arr, int len, int count){
    assert(arr);
    assert(len > 0);
    assert(count > 0);
    //设置双倍字符串
    char *ptemp = (char *)malloc(len * 2 + 1);
    if (NULL == ptemp)
        return;
    char *temp = NULL;
    temp = ptemp;
    strcpy(ptemp, arr);
    strcat(ptemp, arr);
    //在双倍字符串中拿出逆置后的字符串
    strncpy(arr, temp + count, len);
    free(ptemp);
}

void test(){
    char *arr = "ABCD1234";
    int count = 0;
    int len = 0;
    len = strlen(arr);
    Print(arr, len);
    cout << "请输入要左旋的次数：>" << endl;
    cin >> count;
    count %= len;
    string_reverse(arr, len, count);
    Print(arr, len);
}

int main(){
    test();
    system("pause");
    return 0;
}