左旋

1.实现一个函数，可以左旋字符串中的k个字符。 
ABCD左旋一个字符得到BCDA 
ABCD左旋两个字符得到CDAB 

#include<stdio.h>

#include<stdlib.h>
#include<string.h>
void zuoxuan_arr1(char *arr,int sz,int X)
{
int i=0;
int j=0;
X %=sz;
for(i=0;i<X;i++)
{
char temp=arr[0];//先把第一个数存起来
for(j=0;j<sz-1;j++)
{
arr[j]=arr[j+1];//将后面的输依次向前
}
arr[sz-2]=temp;//再把存起来的第一个放到最后一位
}
}
void reserve_string(char * left,char *right)
{
while(left<right)
{
*left^=*right;
*right^=*left;
*left^=*right;
left++;
right--;
}
}


void zuoxuan_arr2(char *arr,int sz,int x)
{
char *start = arr;//定义一个起始指针指向数组的首元素
char *end = arr+sz-1;//定义一个末位地址指向最后一个元素
char *mid = NULL;//定义一个中间指针
x %=sz;//左旋的有效次数，比如长为8的数组左旋100次，前96次其实就相当于无效的，所以就等于左旋了4次
mid = arr+x-1;//如果左旋x位，那么mid则指向第n个元素
reserve_string(start,mid);//首先将前半部分逆置。例：abcd1234，左旋3位。结果：cbad1234
reserve_string(mid+1,end);//再将后半部分逆置---------------------------------cba4321d
reserve_string(start,end);//最后将整体逆置-----------------------------------d1234abc
}


void zuoxuan_arr3(char *arr,int sz,int x)//双倍字符串法
{
char *buff = (char *)malloc(2*sz+1);//创建一个新的空间，大小为arr的长度的2倍加上‘\0’
if(!buff)//如果创建空间失败那么直接返回
{
return;
}
else
{
x %=sz;//左旋的有效次数，比如长为8的数组左旋100次，前96次其实就相当于无效的，所以就等于左旋了4次
strcpy(buff,arr);//把arr拷贝到buff中
strcat(buff,arr);//在buff中再衔接一个arr，那么此时buff中是两个arr连接在一起的结果
strncpy(arr,buff+x,sz);//buff+x，为buff中第x+1元素的地址
//左旋n个：从buff的第n+1个元素往后的sz个元素赋给arr
}
}
int main()
{
char arr[]="ABCDEFG";
int x=0;
int sz=sizeof(arr)/sizeof(arr[0]);
scanf("%d",&x);//输入旋转的位数
/*zuoxuan_arr1(arr,sz,x);
printf("%s\n",arr);*/
/*zuoxuan_arr2(arr,strlen(arr),x);
printf("%s\n",arr);*/
zuoxuan_arr3(arr,strlen(arr),x);
printf("%s\n",arr);
system("pause");
return 0;

}

2.判断一个字符串是否为另外一个字符串旋转之后的字符串。 
例如：给定s1 ＝ AABCD和s2 = BCDAA，返回1，给定s1=abcd和s2=ACBD，返回0. 


AABCD左旋一个字符得到ABCDA 
AABCD左旋两个字符得到BCDAA 

AABCD右旋一个字符得到DAABC 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>


int  compare(char *arr1,char *arr2,int sz1,int sz2)
{
int i=0;
int j=0;
for(i=0;i<sz1;i++)
{
char temp=arr1[0];
for(j=0;j<sz1-1;j++)
{
arr1[j]=arr1[j+1];
}
arr1[sz1-2]=temp;
if(*arr1==*arr2)
{
return 1;
}
}
return 0;
}


char* double_arr1(char *arr,int sz)//双倍字符串法
{
char *buff = (char *)malloc(2*sz+1);//创建一个新的空间，大小为arr的长度的2倍加上‘\0’
if(!buff)//如果创建空间失败那么直接返回
{
return;
}
else
{
strcpy(buff,arr);//把arr拷贝到buff中
strcat(buff,arr);//在buff中再衔接一个arr，那么此时buff中是两个arr连接在一起的结果
}
return buff;
}
int my_strstr(char *buff,char *arr2)
{
char *longp1 = buff;
char *shortp =arr2;
char *s1 = NULL;
if (*arr2=='\0')
{
return 0;//不是
}
while(*longp1)
{
s1 =  longp1;
shortp = arr2;
while(*s1&&*shortp&&(*s1==*shortp))
{
s1++;
shortp++;
}
if(*shortp=='\0')
{
return 1;//是子串
}
longp1++;
}
return -1;//不是
}


int main()
{
char arr1[]="CBDA";
char arr2[]="ACBD";
int ret=0;
char *buff =double_arr1(arr1,strlen(arr1));
ret = my_strstr(buff,arr2);
if(ret==1)
{
printf("是\n");
}
else
{
printf("不是\n");
}
//char arr1[]="abcd";
//char arr2[]="ACBD";
//int ret=0;
//int sz1=sizeof(arr1)/sizeof(arr1[0]);
//int sz2=sizeof(arr2)/sizeof(arr2[0]);
//ret=compare(arr1,arr2,sz1,sz2);
//if(ret==1)//如果返回1则是
//{
// printf("是\n");
//}
//else//如果返回0则不是
//{
// printf("不是\n");
//
//}
system("pause");
return 0;
}