C语言学习练习代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include 
#include 
#include 
#include 
#include 
#include 

//练习54：ferror函数使用
int main()
{
	int c;//注意：int ,非char，要求处理EOF
	FILE* fp=fopen("test,txt","r");
	if(!fp)
	{
		perror("File opening failed");
		return -1;
	}
	//fgetc当读取失败的时候或者遇到文件结束的时候，都会返回EOF
	while((c = fgetc(fp)!= EOF))//标准C I/O读取文件循环
	{
		putchar(c);
	}
	//判断是什么原因结束的
	if(ferror(fp))
		puts("I/O error when reading");
	else if(feof(fp))
		puts("End of file reached successfully");
	//关闭文件
	fclose(fp);
	fp == NULL;
	return 0;
}

//练习53：perror函数使用，报错信息提示自定义
int main()
{
	//strerror-把错误码对应的错误信息的字符串地址返回
	//printf("%s\n",streeror);

	//perror
	FILE* pf = fopen("test2.txt","r");
	if(pf == NULL)
	{
		perror("hehe");//不需要传送错误码信息，hehe:错误信息
		return 0;
	}
	//读文件

	//关闭文件
	fclose(pf);
	pf = NULL;

	return 0;
}

练习52：文件的随机读取
//fseek和ftell和fwind
int main()
{
	char ch;
	//打开文件
	FILE* pf = fopen("test.txt","r");
	if(pf == NULL)
	{
		return 0;
	}
	//定义文件指针
	fseek(pf,2,SEEK_CUR);
	//读取文件
	ch= fgetc(pf);
	printf("%c\n",ch);//%c打印字符
	//关闭文件
	fclose(pf);
	pf=NULL;

	return 0;
}
int main()
{
	int pos = 0;
	//打开文件
	FILE* pf=fopen("test.txt","r");
	if(pf == NULL)
	{
		return 0;
	}
	//定位文件指针
	fseek(pf,-2,SEEK_END);
	pos = ftell(pf);
	printf("%d\n",pos);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}



练习51：二进制读写函数fread和fwrite
struct S 
{
	char name[20];
	int age;
	double score;
};
int main()
{
	struct S s={"张丹",20,21.5};
	FILE* pf=fopen("test.txt","wb");//以二进制形式写入
	if(pf == NULL)
	{
		return 0;
	}
	//二进制形式写文件
	fwrite(&s,sizeof(struct S),1,pf);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

int main()
{
	struct S temp={0};
	FILE* pf=fopen("test.txt","rb");//以二进制形式读取
	if(pf == NULL)
	{
		return 0;
	}
	//二进制形式读文件
	fread(&temp,sizeof(struct S),1,pf);
	printf("%s %d %lf\n",temp.name,temp.age,temp.score);
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

//练习50：sscanf和sprintf
struct S
{
	int n;
	float score;
	char arr[10];
};

int main()
{
	struct S s={100,3.14f,"abcdef"};
	struct S tmp={0};
	char buf[1024]={0};

	sprintf(buf,"%d %f %s",s.n,s.score,s.arr);
	printf("%s\n",buf);
	sscanf(buf,"%d %f %s",&(tmp.n),&(tmp.score),&(tmp.arr));
	printf("%d %f %s\n",tmp.n,tmp.score,tmp.arr);
	return 0;
}


//练习49：文件操作2
//格式化输入输出函数fprintf();fscanf();
struct S
{
	int n;
	float score;
	char arr[10];
};
 int main()
 {
	 struct S s={100,3.14f,"bit"};
	 //打开文件
	 FILE* pf=fopen("test.txt","w");
	 //判断
	 if(pf == NULL)
	 {
		 return 0;
	 }
	 //格式化形式写文件
	 fprintf(pf,"%d %f %s",s.n,s.score,s.arr);
	 //关闭文件
	 fclose(pf);
	 pf = NULL;
	 return 0;
 }

//练习48：文件操作1
int main()
{
	int a=10000;
	FILE* pf=fopen("text.text","wb");
	fwrite(&a,4,1,pf);//二进制的形式写到文件中
	fclose(pf);
	pf=NULL;
	return 0;
}
int main()
{
	//打开二进制文件test.text.fopen打开
	//相对路径
	fopen("test.txt","r");
	//绝对路径,\要再加一个\进行转义
	fopen("D:\\C\\Review\\test11_24\\Project1\\test.txt","r");
	//..表示上一级路径
	//.表示当前路径
	fopen("..\\..\\test.txt","r");
	return 0;
}

int main()
{
	FILE* pf=fopen("text.txt","r");//文件指针接收返回值
	//判断是否打开成功，打开失败会返回null空指针
	if(pf == NULL)
	{
		printf("%s\n",strerror(errno));
		return 0;
	}
	else
	{
		printf("打开文件成功！\n");
	}
	fclose(pf);
	pf = NULL;
	return 0;
}

//顺序读文件
int main()
{
	//打开或建立文件
	FILE* pfwrite = fopen("test.txt","w");
	//判断文件是否打开成功
	if(pfwrite == NULL)
	{
		printf("%s\n",strerror(errno));
	}
	//写文件
	fputc('b',pfwrite);
	fputc('i',pfwrite);
	fputc('t',pfwrite);

	//关闭文件
	fclose(pfwrite);
	pfwrite = NULL;
	return 0;
}

//顺序写文件
int main()
{
	FILE* pfread = fopen("test.txt","r");
	if(pfread == NULL)
	{
		printf("%s\n",strerror(errno));
		return 0;
	}
	//读文件
	printf("%c",fgetc(pfread));
	printf("%c",fgetc(pfread));
	printf("%c",fgetc(pfread));
	printf("\n");
	//关闭文件
	fclose(pfread);
	pfread = NULL;
	return 0;
}

//键盘-标准输入设备-stdout
//屏幕-标准输出设备-stdin
//是一个程序默认打开的两个流设备
//程序默认打开3个。分别是
//stdin FILE*//stdout FILE*//stderr FILE*
int main()
{
	int ch = fgetc(stdin);
	fputc(ch,stdout);
	return 0;
}

读取一行字符串
int main()
{
	//读取字符串的送往地址
	char buf[1024]={0};
	//打开文件
	FILE* pf=fopen("test.txt","r");
	//判断
	if(pf == NULL)
	{
		printf("%s\n",strerror(errno));
		return 0;
	}
	//读取
	fgets(buf,1024,pf);
	printf("%s\n",buf);

	fclose(pf);
	pf=NULL;

	return 0;
}

int main()
{
	//打开文件
	FILE* pf=fopen("test.txt","w");
	//判断
	if(pf == NULL)
	{
		printf("%s\n",strerror(errno));
		return 0;
	}
	//写入
	fputs("hello\n",pf);
	fputs("hello\n",pf);

	fclose(pf);
	pf=NULL;

	return 0;
}

int main()
{
	//从键盘读取一行文本信息
	char buf[1024]={0};
	fgets(buf,1024,stdin);//标准输入读取
	fputs(buf,stdout);//输出到标准输出流
//---------------
//	gets(buf);
//	puts(buf);
	return 0;
}

//练习47：柔性数组的使用2
struct S
{
	int n;
	int* arr;
};
int main()
{
	int i=0;
	int * ptr;
//动态开辟空间，分别两次
	struct S* ps=(struct S*)malloc(sizeof(struct S));
	ps->arr = (int *)malloc(5*sizeof(int));
	
	for(i=0;i<5;i++)
	{
		ps->arr[i]=i;
	}
	for(i=0;i<5;i++)
	{
		printf("%d ",ps->arr[i]);
	}
	printf("\n");
	//调整大小
	ptr=(int *)realloc(ps->arr,10*sizeof(int));
	if(ptr !=NULL)
	{
		ps->arr =ptr;
	}
	for(i=5;i<10;i++)
	{
		ps->arr[i]=i;
	}
	for(i=0;i<10;i++)
	{
		printf("%d ",ps->arr[i]);
	}
	//释放内存
	free(ps->arr);
	ps->arr =NULL;
	free(ps);
	ps=NULL;
	return 0;
}

//练习46：柔性数组的使用1
//优点：流程不易出错，方便内存释放，连续开辟一块动态内存，访问效率更高
struct S
{
	int n;
	int arr[];//大小可以调整，或者写为int arr[0];
};
int main()
{
	struct S*ps=(struct S*)malloc(sizeof(struct S)+5*sizeof(int));
	ps->n=100;
	int i=0;
	for(i=0;i<5;i++)
	{
		ps->arr[i]=i;
	}
	struct S* ptr=realloc(ps,44);
	if(ptr != NULL)
	{
		ps=ptr;
	}
	for(i=5;i<10;i++)
	{
		ps->arr[i]=i;
	}
	for(i=0;i<10;i++)
	{
		printf("%d",ps->arr[i]);
	}
	return 0;
}

//练习45：动态内存使用错误---非法访问内存
//返回栈空间地址的问题，局部变量
char *GetMemory(void)
{
	char p[]="hello world";//局部数组，在函数外之外生命周期结束了
	return p;
}
void Test(void)
{
	char* str=NULL;
	str=GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

//练习44：动态内存空间没有释放，内存泄露（错误示例）
void GetMemory(char* p)
{
	p=(char*)malloc(100);
}
void Test(void)
{
	char *str=NULL;
	GetMemory(str);
	strcpy(str,"hello world");
	printf(str);//没有错误，同printf("abcdef");
}
int main()
{
	Test();
	return 0;
}
//1、运行代码程序会出现崩溃现象
//2、程序存在内存泄漏的问题
//str以值传递的形式给p
//p是GetMemory函数的形参，只能函数内部有效，等GetNemory函数返回之后，动态开辟内存尚未释放并且
//无法找到，所以会造成内存泄露

改正1---传地址
void GetMemory(char** p)
{
	*p=(char*)malloc(100);
}
void Test(void)
{
	char *str=NULL;
	GetMemory(&str);
	strcpy(str,"hello world");
	printf(str);//没有错误，同printf("abcdef");
}
int main()
{
	Test();
	return 0;
}
改进2：使用return

//练习43：模拟实现memmove,处理内存重叠情况
//根据src和dest的大小来选择从前向后拷贝还是从后向前拷贝
//这个会报错，有问题，可修改的左值，迷惑，，，
void* my_memmove(void* dest, const void* src,size_t num)
{
	void* ret=dest;
	//
	assert(dest);
	assert(src);
	//判断
	if(dest < src)//从前向后
	{
		while(num--)
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++((char*)src);
		}
	}
	else
	{
		while(num--)
		{
			(*(char*)dest+num) = *((char*)src+num);
		}
	}

	return ret;
}
int main()
{
	int i=0;
	int arr1[]={1,2,3,4,5,6,7,8,9,10};
	my_memmove(arr1,arr1+3,3);
	for(i=0;i<10;i++)
	{
		printf("%d ",arr1[i]);
	}
	printf("\n");
	return 0;
}

//练习42：模拟实现memcpy
void* my_memcpy(void* dest,const void* src,size_t num)//size_t就是unsigned int
{
	void* ret = dest;
	//指针判断
	assert(dest);
	assert(src);
	//void*不能进行解引用，必须先强制转化
	while(num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;
		++(char*)src;
	}
	return ret;
}
struct S{
	char name[20];
	int age;
};
int main()
{
	struct S arr1[]={{"zhangsan",20},{"lisi",25}};
	struct S arr2[3]={0};
	my_memcpy(arr2,arr1,sizeof(arr1));//num为整个数组的长度，单位为字节
	return 0;
}

//练习41：strtok函数的使用，分割[email protected]
int main()
{
	char str[]={"[email protected]"};
	char p[]={"@."};
	char* ret=0;
	//调用strtok函数会破坏原字符串，因此需要赋值
	char buf[256]={0};
	strcpy(buf,str);
	//调用切割
	ret=NULL;
	for(ret = strtok(str,p);ret != NULL;ret = strtok(NULL,p))
	{
		printf("%s\n",ret);
	}
	return 0;
}

//练习40：模拟实现strstr寻找子串函数
//难！！考虑全面
char * my_strstr(char* p1,char* p2)
{
	char* s1 = p1;
	char* s2 = p2;
	char* cur = p1;
	assert(p1 !=NULL);
	assert(p2 !=NULL);
	if(*p2 == '\0')
	{
		return p1;
	}
	while(*cur)
	{
		s1 = cur;
		s2 = p2;
		while((*s1 != '\0')&&(*s2 !='\0')&&(*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if(*s2 == '\0')
		{
			return cur;
		}
		cur++;
	}
	return NULL;

}

int main()
{
	char p1[]={"abcedf"};
	char p2[]={"ced"};
	char* ret=0;
	ret=my_strstr(p1,p2);
	if(ret != NULL)
	{
		printf("成功\n");
	}
	return 0;
}

//练习39：模拟实现strcmp函数
int my_strcmp(const char* str1,const char*str2)
{
	assert(str1);
	assert(str2);
	while(*str1 == *str2)
	{
		if(*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if(*str1 > *str2)
	{
		return 1;
	}
	else
	{
		return -1;
	}
}
return (*str1 - *str2);
int main()
{
	int ret=0;
	char p1[]={"zbcedfg"};
	char p2[]={"xyz"};
	ret=my_strcmp(p1,p2);
	printf("%d\n",ret);
	return 0;
}

//练习38：实现追加字符串函数模拟实现
//strcat
char* my_strcat(char* dest,const char* src)
{
	char* ret=dest;
	//1、找到目标字符串的\0
	while(*dest != '\0')
	{
		dest++;
	}
	//2、复制
	while(*dest++ = *src++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[30]={"hello"};
	char arr2[]={"world"};
	char* temp=0;
	temp=my_strcat(arr1,arr2);
	printf("%s\n",temp);
	return 0;
}

//练习37：在杨氏矩阵中寻找一个数字
//杨氏矩阵：每行每列都是递增
//要求：时间复杂度小于0(N)
//使用矩阵右上角或者左下角元素进行收缩，每次判断去掉一行或一列
//形参处必须声明，接收数组的大小，行列
int FindNum(int arr[3][3],int k,int row,int col)
{
	int x=0;
	int y=col-1;
	//确定右上角元素坐标
	while((x<=2)&&(y>=0))
	{
		if(arr[x][y]k)
		{
			y--;
		}
		else
		{
			return 1;
		}
	}
	return 0;
}
int main()
{
	int arr[3][3]={{1,2,3},{4,5,6},{7,8,9}};
	int ret=0;
	//封装一个函数，先设定再实现
	ret=FindNum(arr,7,3,3);
	if(ret==1)
	{
		printf("找到了！\n");
	}
	else
	{
		printf("找不到！\n");
	}
	return 0;
}
//改进：可以通过&x,&y返回型参数来带回坐标值


//练习36：判断两个字符串，是否由左旋关系
//abcdefgabcdefg包含左旋后的所有情况--因此寻找此字串
//
int is_move(char* arr1,char* arr2)
{
	int len1=0;
	int len2=0;
	char* temp=NULL;
	//空指针判断
	assert(arr1);
	assert(arr2);
	//1、追加字符串
	len1=strlen(arr1);
	len2=strlen(arr2);
	if(len1 != len2)
	{
		return 0;
	}
	strncat(arr1,arr1,len1);
	//2、判断子串
	temp=strstr(arr1,arr2);
	if(temp==NULL)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
int main()
{
	//不能给常量字符串，要以数组形式，可以改变
	char arr1[20]={"abcdef"};//arr1[]不能空着，一定要开辟足够大的空间
	char arr2[]={"defabc"};
	int ret=0;
	ret=is_move(arr1,arr2);
	if(ret==1)
	{
		printf("YES!\n");
	}
	else
	{
		printf("NO!\n");
	}
	return 0;
}


练习35：左旋字符串
不能使用常量字符串，因为不能被修改，应该使用数组

//1、暴力求解法
void l_rotate(char *arr,int k)
{
	int len=0;
	char temp='0';
	int i=0;
	//传入参数有指针，判断assert
	assert(arr);
	len=strlen(arr);//到0停止，不包含0
	for(i=0;i=2)&&(j>=1))
			{
				arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
			}
		}
	}
	//打印
	for(i=0;i<10;i++)
	{
		for(j=0;j<=i;j++)
		{
			printf("%d ",arr[i][j]);
			
		}
		printf("\n");
	}
	return 0;
}

//练习31：调整数组内容使奇数全部位于偶数前面
//有一些问题，arr[left]和arr[right]
//数组：1 2 3 4 5 6 7 8 9 10

void move(int *arr,int size)
{
	int *left=arr;
	int *right=arr+size-1;
	while(left=2)
	{
		total += empty/2;
		empty=empty/2+empty%2;
	}
	printf("汽水数为：%d\n",total);
	return 0;
}


//练习29：找出1-10000的水仙花数
int main()
{
	int i=0;
	//1、产生1-10000数字
	for(i=0;i<100000;i++)
	{
		int n=1;//记录每个i的位数
		int tmp=i;
		int ret=0;
		//2、判断i
		//123/10 n++
		//12/10 n++
		//1/10=0
		while(tmp/=10)
		{
			n++;
		}
		//3、计算每位数的n次方之和
		//得到每位数字%10
		tmp=i;
		while(tmp)
		{
			ret=ret+pow(tmp%10,n);
			tmp/=10;
		}
		
		//4、判断是否等于i，即为水仙花数
		if(ret==i)
		{
			printf("%d ",i);
		}
	}
	return 0;
}

//练习28：计算实现a+aa+aaa+aaaa+……
int main()
{
	int a=0;
	int n=0;
	int sum=0;
	int i=0;
	int ret=0;
	printf("请输入a和n:\n");
	scanf("%d%d",&a,&n);	
	for(i=0;i=1)
		{
			printf("请输入两个操作数：");
			scanf("%d%d",&x,&y);
			ret = pa[input](x,y);
			printf("结果是:%d\n",ret);
		}
		else if(input == 0)
		{
			printf("退出\n");
			break;
		}
		else
		{
			printf("选择错误\n");
		}
	}while(input);
	return 0;
}

//函数指针数组
int Add(int x,int y)
{
	return x + y;
}
int Sub(int x,int y)
{
	return x - y;
}
int Mul(int x,int y)
{
	return x * y;
}
int Div(int x,int y)
{
	return x / y;
}

int main()
{
	//指针数组
	int * arr[5];
	//需要一个数组，这个数组可以存放4个函数的地址-函数指针的数组
	int (*pa)(int,int)=Add;
	int (*parr[4])(int,int)={Add,Sub,Mul,Div};//函数指针的数组
	int i=0;
	for(i=0;i<4;i++)
	{
		printf("%d\n",parr[i](2,3));
	}
	return 0;
}


//二级指针传参
void test(char **p)
{
}
int main()
{
	char c='b';
	char*pc=&c;
	char**ppc=&pc;
	char* arr[10];
	test(&pc);//可以传一维指针的地址
	test(ppc);//一维指针的指针
	test(arr);//一维指针数组的数组名
	return 0;
}

二维数组传参
void test(int *arr)//err
{
}
void test(int* arr[5])/err
{
}
void test(int (*arr)[5])//right
{
}
void test(int **arr)//err
{
}
int main()
{
	int arr[3][5]={0};
	test(arr);
}

//一维数组传参
#include 
 void test(int arr[])
 {
 }
void test(int arr[10])
{
}
void test(int *arr)
{
}
void test2(int *arr[20])
{
}
void test2(int **arr)
{
}
int main()
{
	int arr[10]={0};
	int *arr2[20]={0};
	test(arr);
	test2(arr2);
	return 0;
}


练习25：判断大端小端字节序存储模式
指针类型决定指针解引用可以访问的字节数
版本1
int main()
{
	int a=1;
	char* p=(char*)&a;
	if(*p == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}
//版本2：使用函数，精简
int check_sys()
{
	int a=1;
	return *(char*)&a;
}

int main()
{
	int ret=0;
	//定义一个函数，返回值为1即为小端；返回值为0即为大端
	ret=check_sys();
	if(ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

//练习24：使用指针实现strcpy
void my_strcpy(char* des,char*src)
{
	while(*src!='\0')
	{
		*des=*src;
		des++;
		src++;
	}
	*des=*src;
}
///改进1：更加精简，判断条件更精妙
void my_strcpy(char* des,char*src)
{
	while(*des++=*src++)
	{
		;	
	}
}
///改进2：先判断指针的有效性，避免程序出问题，但是容易隐匿错误
void my_strcpy(char* des,char*src)
{
	if(des != NULL && src!= NULL)
	{
		while(*des++=*src++)
		{
			;	
		}
	}
}
///改进3：使用assert()断言，发现错误时，及时报错
//包含头文件
#include 
void my_strcpy(char* des,char*src)
{
	assert(des != NULL);//断言，符合条件时继续执行，不符合时报错提示
	assert(src != NULL);//断言判断！！

	while(*des++=*src++)
	{
		;	
	}
}

改进4：使用const,char*
包含头文件,加上返回函数，函数功能更丰富
#include 
char* my_strcpy(char* des,const char*src)
{
	char* ret=des;
	assert(des != NULL);//断言，符合条件时继续执行，不符合时报错提示
	assert(src != NULL);//断言判断！！

	while(*des++=*src++)
	{
		;	
	}
	return ret;
}

int main()
{
	char arr1[]={"#####################"};
	char arr2[]={"bit"};
	my_strcpy(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}


//练习23：递归计算N的K次方
//n^k=n*n^(k-1)
double Power(int n,int k)
{
	if(k<0)
		return 1.0/Power(n,(-k));
	else if(k==0)
		return 1.0;
	else
		return n*Power(n,k-1);
}
int main()
{
	int n=0;
	int k=0;
	double ret=0.0;
	scanf("%d%d",&n,&k);
	ret=Power(n,k);
	printf("%lf\n",ret);
	return 0;
}

//练习22：使用递归来计算一个非负整数各位数字之和
//1729
//DigitSum(172)+9%10
//DigitSum(17)+2%10+9%10
//DigitSum(1)+7%10+2%10++9%10
//1%10+7%10+2%10++9%10
int DigitSum(int num)
{
	int count=0;
	if(num>9)
		return count=DigitSum(num/10)+num % 10;
	else
		return num;
}

int main()
{
	int num=0;
	int sum=0;
	printf("请输入数字：");
	scanf("%d",&num);
	sum=DigitSum(num);
	printf("%d\n",sum);
	return 0;
}

//练习21：分别打印二进制数中的奇数位和偶数位
//32:0000000000000000000000000000000011

void print(int m)
{
	int i=0;
	printf("偶数位：\n");
	for(i=30;i>=0;i=i-2)
	{
		printf("%d ",(m>>i)&1);
	}
	printf("\n");
	printf("奇数位：\n");
	for(i=31;i>=0;i=i-2)
	{
		printf("%d ",(m>>i)&1);
	}
	printf("\n");
}
int main()
{
	int num=0;
	printf("请输入数字：\n");
	scanf("%d",&num);
	print(num);
	return 0;
}


//练习20：数一个二进制数中的1的个数
//这个是最优解！！！！！
//n=n&(n-1)的次数，直至n!=0
//这个循环可以执行的次数=二进制中的1的个数

//计算子函数
//int count_bit_one(int n)
//{
//	int count=0;
//	while(n)
//	{
//		n=n&(n-1);
//		count++;
//	}
//	return count;
//}

//练习19：数组练习
//自己写函数实现1、数组元素初始化
//2、打印数组元素
//3、reverse逆序排列数组元素

//初始化函数
void Init(int arr[],int size)
{
	int i=0;
	for(i=0;i>i)&1))
		{
			count++;
		}
	}
	printf("%d\n",count);
	return 0;
}


//练习16：冒泡排序法,升序排序
//冒泡排序函数
//数组传过去的是数组首元素的地址，&arr[0]
//arr[]为一个指针
void bubble_sort(int arr[],int size)
{
	//这个数组元素为size=9，需要排8趟，size-1
	int i=0;
//采用flag对冒泡排序进行算法优化
	for(i=0;iarr[j+1])
			{		
				int temp=0;
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
                flag=0;
			}
		}
      if(flag==1)
      {
           break;
       }
	}
}
//主函数
int main()
{
	int arr[]={9,8,11,6,5,4,20,2,1};
	int size=0;
	int i=0;
	size=sizeof(arr)/sizeof(arr[0]);
	//排序函数
	bubble_sort(arr,size);
	for(i-0;i10)
	{
		print(input/10);
	}
	printf("%d ",input%10);
}
int main()
{
	int input;
	printf("请输入数字：\n");
	scanf("%d",&input);
	//函数调用
	print(input);
	return 0;
}



//练习12：
//猜数字游戏

//游戏（子函数）
void game()
{
	int ret=0;
	int guess=0;
	printf("欢迎来到猜数字游戏！\n");
	printf("请输入猜测数字：\n");
	//系统随机生成随机数
	//利用不断随时间变化的时间戳来作为生成随机数的变化变量
	//time（）函数可以获取系统时间戳，NULL为空指针
	srand((unsigned int)time(NULL));
	ret=rand();
	ret = ret%100;	
	//printf("%d\n",ret);
	do
	{
		scanf("%d",&guess);
		if(guess>ret)
		{
			printf("猜大了\n");
		}
		else if(guess到sqrt->到在非偶数中找素数
//注意提高代码的效率，培养自己的代码思想
int main()
{
	int i=0;
	int j=0;
	int count=0;
	for(i=101;i<=200;i+=2)
	{
		for(j=2;j<= sqrt(i);j++)
		{
			if(i%j==0)
			{
				break;
			}
		}
		if(j> sqrt(i))
		{
			printf("%d ",i);
			count++;
		}
	}
	printf("\ncount=%d ",count);
	return 0;
}



//练习8：判断输出1000到2000内的闰年
//闰年的判断
//1、被4整除同时不被100整除
//2、被400整除
int main()
{
	int count=0;
	int i=0;
	for(i=1000;i<=2000;i++)
	{
		if(((i%4==0) && (i%100!=0))||(i%400==0))
		{
			count++;
			printf("%d ",i);
		}
	}
	printf("\n,count=%d",count);
	return 0;
}

//练习7：求出两个数的最大公约数
//辗转相除法
int main()
{
	int m=0;
	int n=0;
	int r=0;
	printf("请输入2个数字:\n");
	scanf("%d%d",&m,&n);
///程序效率会更高
wile(r=m%n)
	while(m%n)
	{
		r=m%n;
		m=n;
		n=r;
	}
	printf("最大公约数为%d",n);
}


//练习6：输出1至100中3的倍数
//!!!!!!!有一点疑问，怎么控制逢5换行
int main()
{
	int i=0;
	int j=0;
	for(i=0;i<=100;i++)
	{
		if(i%3 ==0)
		{
			j++;
			printf("%d ",i);
		}
		if(j%5 == 0)
			printf("\n");
	}
	printf("\n");
	return 0;
}





//练习5：比较3个数中的最大，中，最小
//按从大到小的顺序输出

int main()
{
	int a=0;
	int b=0;
	int c=0;
	printf("请输入3个数字：\n");
	scanf("%d%d%d",&a,&b,&c);

	if(aarr[mid])
		{
			left=mid+1;
		}
		else if(mright)
	{
		printf("找不到！\n");
	}
	return 0;
}




//练习题3，在一个有序数组中查找某一个数字，
//第一种方法：按序查找
int main()
{
	int arr[]={1,2,3,4,5,6,7,8,9};
	int i=0;
	int m=0;
	int num=0;
	num=sizeof(arr)/sizeof(arr[0]);//确定数组元素个数
	printf("请输入需要查找的数字：");
	scanf("%d",&m);
	for(i=0;i