左旋

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;
}