#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
使用宏实现两个数中求较大值
//#define MAX(a,b) (a)>(b)?(a):(b)
//
//int main()
//{
// int max = MAX(3,4);
// printf("max = %d",max);
// return 0;
//}
写一个宏可以将一个数字的奇数位和偶数位交换
//#define SWAP(a,b,c) (c = a) ; (a = b); (b = c)
//int main()
//{
// int i = 0;
// int a = 0;
// int j = 0;
// int m = 0;
// int n = 0;
// int tmp = 0;
// scanf("%d",&a);
// for(i=31;i>=0;i-=2)
// {
// j = i;
// m = (a>>j)&1;
// n = (a>>(j-1))&1;
// //tmp = m;
// //m = n;
// //n = tmp;
// SWAP(m,n,tmp); //(() = ();() = ();()=());
// printf("%d%d",m,n);
// }
// return 0;
//}
//#define SWAP(num) (num = ((num & 0xaaaaaaaa) >> 1) | ((num & 0x55555555) << 1))
//int main()
//{
// int num = 30;
// SWAP(num);
// printf("%d\n",num);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
#include
编写函数：
unsigned int reverse_bit(unsigned int value);
这个函数的返回 值value的二进制位模式从左到右翻转后的值。
如：
在32位机器上25这个值包含下列各位：
00000000000000000000000000011001
翻转后：（2550136832）
10011000000000000000000000000000
程序结果返回：
2550136832
//typedef unsigned int unit;
//#include
//unsigned int reverse_bit(unsigned int value)
//{
// int i = 0;
// unsigned int num = 0;
// for(i=0;i<32;i++)
// {
// //num = (unit)(num + ((value >> i) & 1) * pow(2,32-i-1));
// num |= ((value >> i) & 1) << (31 - i); //效率更高 (拿到那一位将它左移到对应位，进行或等就会得到翻转的值)
//
// }
// return num;
//}
//
//int main()
//{
// unsigned int i = 0;
// unsigned int ret = 0;
// scanf("%d",&i); //不能写成 scanf("%u",%i); 程序会崩溃
// ret = reverse_bit(i);
// printf("%u\n",ret);
// //printf("%d\n",sizeof(unit));
// return 0;
//}
不使用（a+b）/2这种方式，求两个数的平均值
方法一
//int Average(int x, int y)
//{
// return y+(x-y)/2;
//}
方法二
//00001010 10
//00010100 20
//
//00000000 &
//00011110 ^
//00001111 ^ >>1
首先，&得到的数字位，只有两个1才得到1，就是进位的1，
而本该向前进一位的1待在了本位。实际上
应该让得到的结果左移1（让进位的1进到合适的位置），
然后再右移1（除以2），得到进位的平均数。
然后，^得到的数字位，实际得到的是本位得到的结果（不包括进位），
让他右移1，得到本位的平均数。
两个平均数相加，得到整个数完整的平均数。
//#include
//int Average(int x, int y)
//{
// return (x & y) + ((x ^ y) >> 1); //(x&y) x和y相同位的平均值 (x^y)>>1 x和y不同位的平均值
//}
//
//int main()
//{
// int a = 25;
// int b = 15;
// int ret = 0;
// ret = Average(a,b);
// printf("%d\n",ret);
// return 0;
//}
编程实现：
一组数据中只有一个数字出现了一次。其他所有数字都是成对出现的。
请找出这个数字。（使用位运算）
//int look_out(int *a, int len)
//{
// int i = 0;
// int ret = 0;
// for(i=0;i
#define _CRT_SECURE_NO_WARNINGS 1
//#include
递归和非递归分别实现求第n个斐波那契数
递归的方法
/*int Fib(int n)
{
if(n<=2)
{
return 1;
}
else
{
return Fib(n-1)+Fib(n-2);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fib(n);
printf("ret = %d\n",ret);
return 0;
}*/
循环的方法
/*int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while(n>2)
{
c = a+b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fib(n);
printf("ret = %d\n",ret);
return 0;
}*/
编写一个函数实现n^k，使用递归实现
n^k = n*n^k-1
/*int second_party(int n ,int k)
{
if(k>0)
{
return second_party(n,k-1)*n;
}
else
{
return 1;
}
}
int main()
{
int n = 0;
int k = 0;
int ret = 0;
scanf("%d %d",&n,&k);
ret = second_party(n,k);
printf("n的k次方是:%d\n",ret);
return 0;
}*/
写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和，例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
/*int dig_itsum(int n)
{
if((n/10)>0)
{
return n%10 + dig_itsum(n/10);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = dig_itsum(n);
printf("ret = %d\n",ret);
return 0;
}*/
递归和非递归分别实现strlen
非递归
/*#include
int my_strlen(char *p)
{
int count = 0;
assert(p != NULL);
while(*p != '\0')
{
count++;
*p++;
}
return count;
}
int main()
{
char *ch = "abcdefg"; // 错误的写法char = "abcdef";
int i = 0;
i = my_strlen(ch);
printf("%d\n",i);
return 0;
}*/
递归
/*#include
int my_strlen(char *p)
{
assert(p != NULL);
if(*p != '\0')
{
return 1 + my_strlen(p+1);//错误的写法(*p+1)
}
else
{
return 0;
}
}
int main()
{
char *ch = "abcdefgh";
int i = 0;
i = my_strlen(ch);
printf("%d\n",i);
}*/
递归和非递归分别实现求n的阶乘
非递归
/*int Fun(int n)
{
int i = 0;
int ret = 1;
for(i = 1;i<=n;i++)
{
ret = ret * i;
}
return ret;
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fun(n);
printf("%d\n",ret);
return 0;
}*/
递归
/*int Fun(int n)
{
if(n<2)
{
return 1;
}
else
{
return n * Fun(n-1);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fun(n);
printf("%d\n",ret);
return 0;
}*/
递归方式实现打印一个整数的每一位
/*void Fun(int num)
{
if(num >9)
{
Fun(num/10); // printf()不能写到 if语句的里面
}
printf("%d ",num%10);
}
int main()
{
int num = 0;
scanf("%d",&num);
Fun(num);
return 0;
}*/
编写一个函数reverse_string(char * string)（递归实现）
实现：将参数字符串中的字符反向排列。
要求：不能使用C函数库中的字符串操作函数。
//#include
//void reverse_string(const char *p)
//{
// assert(p != NULL);
// if(*p != '\0')
// {
// reverse_string(p+1);
// }
// printf("%c ",*p);
//}
//
//int main()
//{
// char *ch = "abcdef";
// reverse_string(ch);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。
找出这两个数字，编程实现。
//int Find(int sz, int arr[])
//{
// int i = 0;
// int ret = 0;
// for(i=0;i++;i1)
// {
// water = water + bottle/2;
// bottle = bottle/2+bottle%2;
// }
// return water;
// //return money*2-1;
//}
//int main()
//{
// int i = 0;
// int ret = 0;
// scanf("%d",&i);
// ret = Exchange(i);
// printf("%d\n",ret);
// return 0;
//}
模拟实现strcpy
//#include
//char *my_strcpy(char *dst, const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
//
// while(*src != '\0')
// {
// *dst = *src;
// dst++;
// src++;
// }
// return dst;
//}
//char *my_strcpy(char *dst, const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
//
// while(*dst++ = *src++)
// {
// ;
// }
// return dst;
//}
//
//int main()
//{
// char *ch = "abcdef";
// char buf[10] = {0};
// char *ret = my_strcpy(buf,ch);
// printf("buf:%s\n",buf);
// return 0;
//}
模拟实现strcat
//#include
//
//char *my_strcat(char *dst,const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
// while(*dst)
// {
// dst++;
// }
// while(*dst++ = *src++)
// {
// ;
// }
// return ret;
//}
//
//int main()
//{
// char arr1[20] = "abcd"; //定义的数组大小要大于链接后的大小
// char arr2[] = "aefgh";
// //char *ret = my_strcat(arr1,arr2);
// my_strcat(arr1,arr2);
// printf("连接后的结果：%s\n",arr1);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
#include
作业19
模拟strcpy函数
//#include
//char *my_strcpy(char *dst, const char *src)
//{
// char *p = dst;
// assert(dst);
// assert(src);
// while(*dst++ = *src++)
// {
// ;
// }
// return dst;
//}
//
//int main()
//{
// char *cp = "abcde12345";
// char arr[20];
// printf("%s\n",cp);
// my_strcpy(arr,cp);
// printf("%s\n",arr);;
// return 0;
//}
模拟strcat(字符串拼接)
//#include
//char *my_strcat(char *dst, const char *src)
//{
// char *p = dst;
// assert(dst);
// assert(src);
// while(*dst) //while(*dst++) 错误的 //while((*dst)++) 错误的
// {
// dst++;
// }
// while(*dst++ = *src++)
// {
// ;
// }
// return p;
//}
//
//int main()
//{
// char arr[20] = "abcde";
// char *cp = "456789";
// printf("%s\n",arr);
// my_strcat(arr,cp);
// printf("%s\n",arr);
// return 0;
//}
模拟strstr(判断字符串1是不是字符串2的子串)
#include
#include
char *my_strstr(const char *dst,const char *src)
{
const char *end = dst + strlen(dst) - strlen(src) + 1; //优化的地方
const char *d = dst;
assert(dst);
assert(src);
while(d < end)
{
const char *p = d;
const char *s = src;
while(*s)
{
if(*p == *s)
{
p++;
s++;
}
else
{
break;
}
}
if(*s == '\0')
{
return d;
}
d++;
}
}
//#include
//char *my_strstr(const char *dst, const char *src)
//{
// const char *d = dst;
// assert(dst);
// assert(src);
// while(d)
// {
// const char *p = d;
// const char *s = src;
// while((*p != '\0') && (*s != '\0') && (*p == *s))
// {
// s++;
// p++;
// }
// if(*s == '\0')
// {
// return d;
// }
// d++;
// }
//}
//
//int main()
//{
// char *s = "abcdefg";
// char *p = "cdef";
// //char *ch = "higk";
// char * ret = my_strstr(s,p);
// //char * ret = my_strstr(s,ch);
// printf("%s\n",ret);
// return 0;
//}
//模拟实现strchr
//#include
//char *my_strchr(const char *dst, char c)
//{
// assert(dst);
// while((*dst != c) && (*dst != '\0'))
// {
// dst++;
// }
// return *dst == c ? dst:NULL;
//}
//
//int main()
//{
// char *s = "abcdef";
// char c = 'g';
// char *ret = my_strchr(s, c);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strcmp
//#include
//int my_strcmp(const char *dst, const char *src)
//{
// assert(dst);
// assert(src);
// while(*dst != '\0' && *src != '\0')
// {
// if(*dst == *src)
// {
// dst++;
// src++;
// }
// else if(*dst > *src)
// {
// return 1;
// }
// else
// {
// return -1;
// }
// }
// if(*dst != '\0')
// {
// return 1;
// }
// if(*src != '\0')
// {
// return -1;
// }
// return 0;
//}
//#include
//int my_strcmp(const char *dst, const char *src)
//{
// int ret = 0;
// assert(dst);
// assert(src);
// while(!(ret = *(unsigned char *)dst - *(unsigned char *)src) && *src)
// {
// dst++;
// src++;
// }
// if(ret > 0)
// {
// ret = 1;
//
// }
// else
// {
// return -1;
// }
// return ret;
//}
//
//int main()
//{
// char *ch = "abcde";
// char *cp = "abcdef";
// int ret = my_strcmp(ch,cp);
// printf("%d\n",ret);
// return 0;
//}
模拟实现memcpy
//#include
//#include
//char *my_memcpy(void *dst, const void *src, int count)
//{
// char *d = dst;
// const char *s = src;
// assert(dst);
// assert(src);
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
// return dst;
//}
//
//int main()
//{
// char p[] = "abcdef";
// char arr[10];
//
// //printf("%d\n",strlen(s));
// my_memcpy(arr,p,sizeof(p));
// printf("%s\n",arr);
// return 0;
//}
模拟实现memmove
//#include
//#include
//void *my_memmove(void *dst, const void *src, int count)
//{
// char *d = dst;
// const char *s = src;
// assert(dst);
// assert(src);
//
//if(s < d && s+count >d)
//{
// d = d + count -1;
// s = s + count -1;
// while(count--)
// {
// *d = *s;
// --d;
// --s;
// }
//}
//else
//{
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
//}
// if(d <= s || s+count <= d) //错误的 if(d <= s && s+count <= d)
// {
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
// }
// else
// {
// d = d + count -1;
// s = s + count -1;
// while(count--)
// {
// *d = *s;
// d--;
// s--;
// /*--s;
// --d;*/
// }
// }
//
// return dst;
//}
//
//int main()
//{
// char ch[64]= "abcdefghijk";
// my_memmove(ch,ch+1,strlen(ch));
// printf("%s\n",ch);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
///作业20
//int *p; --> 指针
//int arr[5]; --> 数组
//int *p[5]; --> 指针数组
//int (*p)[5]; --> 数组指针
//int *((*p)[5]); --> 指针数组的指针
//int *((*p)[10])[5]; --> 指针数组指针的数组
//int (*p[10])[5]; --> 数组指针数组
//int *(*p[5])[5]; --> 数组指针数组的指针
//
//
//int test() --> 函数的声明
//int *ptest() -->指针函数 //是否存在？ 不存在
//viod *ptest() -->函数指针
//int (*ptest)() --> 函数指针
//
//(void (*)() 函数指针 --> void(*)()0 将0强转为函数指针 -->
//(void(*)()0) 对0这个函数指针解引用 --> (*(void(*)()0)() -->
//调用函数，这个函数为:无返回类型参数为空的函数
//
//void(*signal(int,void(*)(int)))(int);
//
//typedef void(*pfun_t)(int); -->定义了一个 函数指针类型
//返回值为void 参数为int 的函数指针类型
//
//pfun_t signal(int, pfun_t) --> 返回值为 函数指针 参数为 int和函数指针 的函数声明
//
//int (*p[5])() -->函数指针数组
//int *p[5]() --> 不存在这样的东西
//int (*)()p[5] -->错误的,语法错误
//
//int ((*p)[5])() -->数组指针函数
//int (*(*p)[5])() -->函数指针数组指针
//int (*(*p[10])[5])() -->函数指针数组指针的数组
#define _CRT_SECURE_NO_WARNINGS 1
#include
函数指针数组的用法（转移表） 计算器
//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 input = 1; //初值不能为零
// int x = 0;
// int y = 0;
// int ret = 0;
// int (*p[5])(int x, int y) = {0,add,sub,mul,div}; //转移表
// while(input)
// {
// printf("*************************\n");
// printf("***1.add 2.sub***\n");
// printf("***3.mul 4.div***\n");
// printf("*************************\n");
// printf("请选择: ");
// scanf("%d",&input);
// if((input>0) && (input<5))
// {
// printf("请输入操作数 ");
// scanf("%d%d",&x,&y);
// ret = (*p[input])(x, y);
// }
// else
// {
// printf("选择错误");
// break;
// }
// printf("ret = %d\n",ret);
// printf("\n");
// printf("\n");
// printf("\n");
// printf("-------------------------\n");
// }
// return 0;
//}
回调函数
模拟实现qsort（采用冒泡法）
//int int_cmp(const void *x, const void *y)
//{
// int *a = (int *)x;
// int *b = (int *)y;
// return *a > *b ? 1 : *a < *b ? -1 : 0;
//}
//
//void swap(void *x, void *y,int size)
//{
// char *a = (char *)x;
// char *b = (char *)y;
// while(size--)
// {
// *a ^= *b;
// *b ^= *a;
// *a ^= *b;
// a++; //不能少
// b++;
// }
//}
//
//void bubble(void *arr, int count, int size, int(*cmp)(void *x, void *y))
//{
// int i = 0;
// int j = 0;
// int flag = 0;
// for(i = 0;i 0) //注意最后的>0
// {
// flag = 1;
// swap((char *)arr + j*size, (char *)arr + (j+1)*size, size);
// }
// }
// if(0 == flag)
// {
// break;
// }
// }
//}
//
//void print_arr(int arr[10], int sz)
//{
// int i = 0;
// for(i=0;i
#define _CRT_SECURE_NO_WARNINGS 1
#include
模拟实现strncat
//#include
//#include
//
//char *my_strncat(char *dst, const char *src, int num)
//{
// char *ret = dst;
// assert(dst);
// assert(src);
// while(*dst)
// {
// ++dst;
// }
// while(num--)
// {
// *dst = * src;
// dst++;
// src++;
// }
// return ret;
//}
//
//int main()
//{
// char arr[64] = "abcdefg";
// char *ch = "hijklmn";
// int sz = strlen(ch);
// char *ret = my_strncat(arr,ch,sz);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strncpy
//#include
//#include
//char *my_strncpy(char *dst, const char *src, int num)
//{
// char *ret = dst;
// assert(dst);
// assert(src);
// while(num--)
// {
// *dst = *src;
// dst++;
// src++;
// }
// return ret;
//}
//
//int main()
//{
// char arr[64];
// char *ch = "opqrstuvwxyz";
// int sz = strlen(ch) + 1; //需要手动加\0
// char *ret = my_strncpy(arr,ch,sz);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strncmp
//#include
//int my_strncmp(const char *p, const char *q, int num)
//{
// assert(p);
// assert(q);
// while(num--)
// {
// if(*p > *q)
// {
// return 1;
// }
// else if(*p < *q)
// {
// return -1;
// }
// else
// {
// p++;
// q++;
// }
// }
// return 0;
//}
//
//int main()
//{
// char *ch = "abcde";
// char *cp = "abcdef";
// int ret = my_strncmp(ch,cp,6);
// printf("%d\n",ret);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
交换俩个整形变量的值
//int main()
//{
解法一
//int a = 10;
//int b = 20;
//int c = 0;
//c = a;
//a = b;
//b = c;
//解法二
//int a = 34;
//int b = 26;
//a = a+b;
//b = a-b;
//a = a-b;
//解法三
//int a = 97;
//int b = 25;
//a = a^b;
//b = a^b;
//a = a^b;
//printf("%d,%d",a,b);
//return 0;
//}
求10 个整数中最大值（可以改变数组的值）
//int main()
//{
// int arr[] = {-6,-8,-4,-9,-2,-10,-7,2,-1,-5};
// int max = arr[0];
// int i = 0;
// for(i=1;i<10;i++)
// {
// if(arr[i]>max)
// {
// max = arr[i];
// }
// }
// printf("%d\n",max);
//return 0;
//}
将三个数按从大到小输出 或者 //用函数的方式
//void Swap(int *p1 , int *p2)
//{
// int tmp = *p1;
// *p1 = *p2;
// *p2 = tmp;
//}
//int main ()
//{
// int a = 0;
// int b = 0;
// int c = 0;
// int tmp = 0;
// scanf("%d %d %d",&a,&b,&c);
//
// if(a
//int main()
//{
// int i = 0;
// double sum = 0.0;
// double n = -1;
// for(i=1;i<=100;i++)
// {
// n = -1; //每次进入循环n都要初始化
// n = pow (n, (i+1));
// sum = sum + n * (1.0/i);
// }
// printf("%lf",sum);
//return 0;
//}
//int main()
//{
// int i = 0;
// double sum = 0.0;
// int flag = -1;
// for(i=1;i<=100;i++)
// {
// sum = sum+flag*1.0/i;
// flag = -flag;
// }
// printf("%lf",sum);
//return 0;
//}
将数组A中的内容和数组B中的内容进行交换
//int main ()
//{
// int arrA[] = {1,2,3,4,5,6,7,8,9,10};
// int arrB[] = {-1,-2,-3,-4,-5,-6,-7,-8,-9,-10};
// int tmp = 0;
// int i = 0;
// //int sz = sizeof(arrA)/sizeof(arrA[0]);
//
// //交换两个数组的内容
// for(i=0;i<10;i++) //for(i=0;i
//int main()
//{
// int i = 0;
// int bit = 1;
// for(i=0;i<1000;i++)
// {
// //计算是几位数
// //scanf("%d",&i);
// int tmp = i;
// int sum = 0;
// bit = 1; 这一句很重要（每一个数进来要将bit置1）
// while(tmp/10)
// {
// bit++;
// tmp = tmp/10;
// }
// //printf("%d",bit);
// 取下每一位
// tmp = i;
// while(tmp) //不能是(tmp%10),会将370 ，407 这样有零的数字丢失
// {
// sum = sum + pow(tmp%10,bit);
// tmp = tmp /10;
// }
// if(sum == i)
// {
// printf(" %d ", i );
// }
//
// }
// return 0;
//}
求Sn=a+aa+aaa+aaaa+aaaaa的前5项之和
//int main()
//{
//
// int i = 0;
// int a = 0;
// int sn = 0;
// int ret = 0;
// int tmp = 0;
//
// scanf("%d%d",&a,&tmp);
// for(i=0;i
//int main()
//{
// int ch = 0;
// while((ch = getchar()) != EOF)
// {
// if((ch>='a')&&(ch<='z'))
// {
// putchar(toupper(ch));
// //putchar(ch-32);
// //putchar(ch-('a'-'A'));
// }
// else if((ch>='A')&&(ch<='Z'))
// {
// putchar(tolower(ch));
// //putchar(ch+32);
// //putchar(ch+'a'-'A');
// }
// }
//return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
//int main()
//{
// //printf("file:%s line:%d\n",__FILE__,__LINE__);
// printf("date:%d time:%d",__DATE__,__TIME__);
// return 0;
//}
//int main()
//{
// int i = 0;
// int arr[10] = {0};
//
// for(i=0;i<=12;i++)
// {
// arr[i] = i;
// printf("hehe\n");
// }
// return 0;
//}
使用宏实现两个数中求较大值
//#define MAX(a,b) (a)>(b)?(a):(b)
//
//int main()
//{
// int max = MAX(3,4);
// printf("max = %d",max);
// return 0;
//}
写一个宏可以将一个数字的奇数位和偶数位交换
//#define SWAP(a,b,c) (c = a) ; (a = b); (b = c)
//int main()
//{
// int i = 0;
// int a = 0;
// int j = 0;
// int m = 0;
// int n = 0;
// int tmp = 0;
// scanf("%d",&a);
// for(i=31;i>=0;i-=2)
// {
// j = i;
// m = (a>>j)&1;
// n = (a>>(j-1))&1;
// //tmp = m;
// //m = n;
// //n = tmp;
// SWAP(m,n,tmp); //(() = ();() = ();()=());
// printf("%d%d",m,n);
// }
// return 0;
//}
计算奇数的个数
//int Detr(int arr[],int sz)
//{
// int i = 0;
// int count = 0;
// for(i=0;i2)&&(n>2))
// {
// printf("找不到\n");
// }
//}
//
//int main()
//{
// int arr[3][3] = {{1,2,3},{2,3,4},{3,4,5}};
// //int i = 0;
// //int j = 0;
// //for(i=0;i<3;i++)
// //{
// // for(j=0;j<3;j++)
// // {
// // printf("%d",arr[i][j]);
// // }
// // printf("\n");
// //}
// int key = 6;
// Rearch(arr,3,3,key);
// return 0;
//}
//
//#include
//int main()
//{
// char arr[] = "abcdef";
// //int sz = sizeof(arr)/sizeof(arr[0])-1;
// //Levo();
// //int sz = strlen(arr);
//
// printf("%d\n",arr);
//
//
// return 0;
//}
//int main()
//{
// int i = 0;
// int arr[10] = {0};
// for(i=0;i<=12;i++)
// {
// arr[i] = 0;
// printf("hehe\n");
// }
// return 0;
//}
//int main()
//{
// main();
// return 0;
//}
接受一个整型值（无符号），把它转换为字符并打印它
例如 输入1234 输出1 2 3 4
//void Print(int num)
//{
// if(num>9)
// {
// Print(num/10);
// }
// printf("%d ",num%10);
// //return num%10 ; 不能用return 无输出
//}
//
//int main()
//{
// int num = 1234;
// Print(num);
// return 0;
//}
编写函数不允许创建临时变量，求字符串长度
//#include
//int my_strlen(const char *str)
//{
// //int count = 0;
//
// assert(str != NULL);
//
// //while(*str != '\0')
// //{
// // count++;
// // *str++;
// //}
//
//
// if(*str != '\0')
// {
// //str++;
// return 1+my_strlen(str+1); //return 1+my_strlen(str);
// }
// else
// return 0;
//
// //return count;
//}
//
//
//int main()
//{
// char *ch = "abcdefghijklmn"; //不能写成char ch = "abcdef";
// int ret = my_strlen(ch);
// printf("%d\n",ret);
// return 0;
//}
//求n的阶乘
//
//int Fun(int n)
//{
// if(n<=1) //0的阶乘是1
// {
// return 1;
// }
// else
// {
// return n*Fun(n-1);
// }
//}
//
//int main()
//{
// int n = 0;
// int ret = 0;
// scanf("%d",&n);
// ret= Fun(n);
// printf("%d",ret);
// return 0;
//}
求第n个斐波那契数（不考虑溢出）
1 1 2 3 5 8 13 21 34 55 89 ......
循环方式
//int Fbc(int n)
//{
//
// int a = 1;
// int b = 1;
// int c = 1;
// while(n>2)
// {
// n = n-1;
// c = a+b;
// a = b;
// b = c;
//
// }
// return c;
//}
递归的方式
//Fbc(int n)
//{
//
// if(n<=2)
// return 1;
// else
// return Fbc(n-1)+Fbc(n-2);
//
//}
//int main()
//{
// int ret = 0;
// int n = 0;
// scanf("%d",&n);
// ret = Fbc(n);
// printf("%d",ret);
// return 0;
//}
//int main(int argc, char*argv[], char*envp[])
//{
// int i = 0;
// for(i=0;i
//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 argc, char*argv[], char*envp[])
//{
// int x = 0;
// int y = 0;
// int ret = 0;
// if(argc != 4)
// {
// printf("参数有误\n");
// return 1;
// }
// x = atoi(argv[2]);
// y = atoi(argv[3]);
// switch(*(argv[1]+1))
// {
// case'a':
// ret = Add(x, y);
// break;
// case's':
// ret = Sub(x, y);
// break;
// case'm':
// ret = Mul(x, y);
// break;
// case'd':
// ret = Div(x, y);
// break;
// }
// printf("ret = %d",ret);
// return 0;
//}
作业15
使用可变参数，实现函数，求函数参数的平均值
//#include
//int avervge(int n,...)
//{
// int i = 0;
// int sum = 0;
// va_list arg; ///是宏 不是函数
// // typedef char * va_list;
// va_start(arg,n);
// //#define va_start _crt_va_start
// //#define _crt_va_start(ap,v) ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
// // (arg = (char *) &(n))+(向上取整（1-4，取4；5-8，取8）)
//
// for(i=0;i (*(&(n)+2+i)) ) 这里很容易出错，注意书写
// {
// max = max;
// }
// else
// {
// max = *(&(n)+2+i); 这里很容易出错，注意书写
// }
// }
//
// return max;
//}
//
//
//int main()
//{
// int max = 0;
// max = Max(5,7,25,5,3,36);
// printf("max = %d\n",max);
// return 0;
//}
求任意个数的平均值
//int average(int n,...)
//{
// int i = 0;
// int sum = 0;
// for(i=0;i0)
// {
// return second_party(n,k-1)*n;
// }
// else
// {
// return 1;
// }
//}
//
//int main()
//{
// int n = 0;
// int k = 0;
// int ret = 0;
// scanf("%d %d",&n,&k);
// ret = second_party(n,k);
// printf("n的k次方是:%d\n",ret);
// return 0;
//}
写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和，例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
//int dig_itsum(int n)
//{
// while(n/10) //if((n/10)>0)
// {
// return n%10 + dig_itsum(n/10);
// }
//}
//
//int main()
//{
// int n = 0;
// int ret = 0;
// scanf("%d",&n);
// ret = dig_itsum(n);
// printf("ret = %d\n",ret);
// return 0;
//}
//#include
//int my_strlen(const char *p)
//{
// int count = 0;
// assert(p != NULL);
// while(*p != '\0')
// {
// count++;
// *p++;
// }
// return count;
//}
//
//int main()
//{
// char *ch = "abcdefg";
// int i = 0;
// i = my_strlen(ch);
// printf("%d\n",i);
// return 0;
//}
//#include
//int my_strlen(char *p)
//{
// assert(p != NULL);
// if(*p != '\0')
// {
// return 1 + my_strlen(p+1);// 错误的写法 (*p+1)
// }
// else
// {
// return 0;
// }
//}
//
//int main()
//{
// char *ch = "abcdefgh";
// int i = 0;
// i = my_strlen(ch);
// printf("%d\n",i);
//}
//void Fun(int num)
//{
// if(num >9)
// {
// Fun(num/10);
// }
// printf("%d ",num%10);
//}
//
//int main()
//{
// int num = 0;
// scanf("%d",&num);
// Fun(num);
// return 0;
//}
作业 15 递归
//#include
递归和非递归分别实现求第n个斐波那契数
递归的方法
/*int Fib(int n)
{
if(n<=2)
{
return 1;
}
else
{
return Fib(n-1)+Fib(n-2);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fib(n);
printf("ret = %d\n",ret);
return 0;
}*/
循环的方法
/*int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while(n>2)
{
c = a+b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fib(n);
printf("ret = %d\n",ret);
return 0;
}*/
编写一个函数实现n^k，使用递归实现
n^k = n*n^k-1
/*int second_party(int n ,int k)
{
if(k>0)
{
return second_party(n,k-1)*n;
}
else
{
return 1;
}
}
int main()
{
int n = 0;
int k = 0;
int ret = 0;
scanf("%d %d",&n,&k);
ret = second_party(n,k);
printf("n的k次方是:%d\n",ret);
return 0;
}*/
写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和，例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19
/*int dig_itsum(int n)
{
if((n/10)>0)
{
return n%10 + dig_itsum(n/10);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = dig_itsum(n);
printf("ret = %d\n",ret);
return 0;
}*/
递归和非递归分别实现strlen
非递归
/*#include
int my_strlen(char *p)
{
int count = 0;
assert(p != NULL);
while(*p != '\0')
{
count++;
*p++;
}
return count;
}
int main()
{
char *ch = "abcdefg"; // 错误的写法char = "abcdef";
int i = 0;
i = my_strlen(ch);
printf("%d\n",i);
return 0;
}*/
递归
/*#include
int my_strlen(char *p)
{
assert(p != NULL);
if(*p != '\0')
{
return 1 + my_strlen(p+1);//错误的写法(*p+1)
}
else
{
return 0;
}
}
int main()
{
char *ch = "abcdefgh";
int i = 0;
i = my_strlen(ch);
printf("%d\n",i);
}*/
递归和非递归分别实现求n的阶乘
非递归
/*int Fun(int n)
{
int i = 0;
int ret = 1;
for(i = 1;i<=n;i++)
{
ret = ret * i;
}
return ret;
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fun(n);
printf("%d\n",ret);
return 0;
}*/
递归
/*int Fun(int n)
{
if(n<2)
{
return 1;
}
else
{
return n * Fun(n-1);
}
}
int main()
{
int n = 0;
int ret = 0;
scanf("%d",&n);
ret = Fun(n);
printf("%d\n",ret);
return 0;
}*/
递归方式实现打印一个整数的每一位
/*void Fun(int num)
{
if(num >9)
{
Fun(num/10); // printf()不能写到 if语句的里面
}
printf("%d ",num%10);
}
int main()
{
int num = 0;
scanf("%d",&num);
Fun(num);
return 0;
}*/
编写一个函数reverse_string(char * string)（递归实现）
实现：将参数字符串中的字符反向排列。
要求：不能使用C函数库中的字符串操作函数。
//#include
//void reverse_string(const char *p)
//{
// assert(p != NULL);
// if(*p != '\0')
// {
// reverse_string(p+1);
// }
// printf("%c ",*p);
//}
//
//int main()
//{
// char *ch = "abcdef";
// reverse_string(ch);
// return 0;
//}
作业17
一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。
找出这两个数字，编程实现。
//int Find(int sz, int arr[])
//{
// int i = 0;
// int ret = 0;
// for(i=0;i++;i1)
// {
// water = water + bottle/2;
// bottle = bottle/2+bottle%2;
// }
// return water;
// //return money*2-1;
//}
//int main()
//{
// int i = 0;
// int ret = 0;
// scanf("%d",&i);
// ret = Exchange(i);
// printf("%d\n",ret);
// return 0;
//}
模拟实现strcpy
//#include
//char *my_strcpy(char *dst, const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
//
// while(*src != '\0')
// {
// *dst = *src;
// dst++;
// src++;
// }
// return ret;
//}
//char *my_strcpy(char *dst, const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
//
// while(*dst++ = *src++)
// {
// ;
// }
// return ret;
//}
//
//int main()
//{
// char *ch = "abcdef";
// char buf[10] = {0};
// char *ret = my_strcpy(buf,ch);
// printf("buf:%s\n",buf);
// return 0;
//}
模拟实现strcat
//#include
//
//char *my_strcat(char *dst,const char *src)
//{
// char *ret = dst;
// assert(dst != NULL);
// assert(src != NULL);
// while(*dst)
// {
// dst++;
// }
// while(*dst++ = *src++)
// {
// ;
// }
// return ret;
//}
//
//int main()
//{
// char arr1[20] = "abcd"; //定义的数组大小要大于链接后的大小
// char arr2[] = "aefgh";
// //char *ret = my_strcat(arr1,arr2);
// my_strcat(arr1,arr2);
// printf("连接后的结果：%s\n",arr1);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
计算器
//#include
//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 argc, char*argv[], char*envp[])
//{
// int x = 0;
// int y = 0;
// int ret = 0;
// if(argc != 4)
// {
// printf("参数有误\n");
// return 1;
// }
// x = atoi(argv[2]);
// y = atoi(argv[3]);
// switch(*(argv[1]+1))
// {
// case'a':
// ret = Add(x, y);
// break;
// case's':
// ret = Sub(x, y);
// break;
// case'm':
// ret = Mul(x, y);
// break;
// case'd':
// ret = Div(x, y);
// break;
// }
// printf("ret = %d\n",ret);
// return 0;
//}
冒泡排序可以排序字符串
//#include
//void Swap(char *x,char *y)
//{
// assert(x);
// assert(y);
// *x ^= *y;
// *y ^= *x;
// *x ^= *y;
//}
//
数组下标索引的方式
//void bubble_sort(char arr[],int len)
//{
// int i = 0;
// int j = 0;
// for(i=0;iarr[j+1])
// {
// flag = 1;
// Swap(&arr[j],&arr[j+1]);
//
// }
// }
// if(0 == flag) //
// {
// break;
// }
// }
//}
指针的方式1
//void bubble_sort(char *arr, int len)
//{
// char *start = arr;
// char *end = (arr+len-1);
// assert(arr);
// while(end > arr)
// {
// int flag = 0;
// for(start = arr; start < end; start++)
// {
//
// if(*start > *(start+1))
// {
// Swap(start,(start+1)); //传的本身就是地址
// flag = 1;
// }
//
// }
if(!flag)
// {
// break;
// }
// end--; // 不能忘记
// }
//}
指针的方式2
void bubble_sort(char *arr,int len)
{
char *start = arr;
char *end = arr+len-1;
for(end =(arr+len-1);end > arr;end--)
{
int flag = 0;
for(start = arr;start < end;start++)
{
if(*start >*(start+1))
{
Swap(start,start+1);//传的本身就是地址
flag = !flag;
}
}
if(0 == flag)
{
break;
}
}
}
//void Show(char arr[],int len)
//{
// int i = 0;
// for(i=0;i
//int main()
//{
// char arr[] = "kjhadsbc";
// //printf("%d\n",strlen(ch));
// int len = 0;
// len = sizeof(arr)/sizeof(arr[0])-1;
// //len = strlen(arr);
// Show(arr,len);
// bubble_sort(arr,len);
// Show(arr,len);
// return 0;
//}
//int main()
//{
// int count = 0;
// char ch = 0;
// while((ch = getchar()) != EOF)
// {
// if(ch == '{')
// count++;
// else if((ch == '}') && (count == 0))
// {
// printf("不匹配\n");
// return 0;
// }
// else if(ch == '}')
// count--;
// }
// if(count == 0)
// printf("匹配\n");
// else
// printf("不匹配\n");
// return 0;
//}
//杨氏矩阵
//有一个二维数组.
//数组的每行从左到右是递增的，每列从上到下是递增的.
//在这样的数组中查找一个数字是否存在。
//时间复杂度小于O(N);
//
//数组：
//1 2 3
//2 3 4
//3 4 5
//
//
//1 3 4
//2 4 5
//4 5 6
数组的方式
//int Seek(int arr[][4],int row, int key)
//{
// int i = 0;
// int j = row-1;
// while(i=0)
// {
// if(arr[i][j] == key)
// {
// printf("存在\n");
// return 0;
// }
// else if(arr[i][j] > key)
// {
// j--;
// }
// else
// {
// i++;
// }
// }
// printf("不存在\n");
// return 0;
//}
指针的方式
//#include
//int Seek(int *arr, int row , int col, int key)
//{
// int i = 0;
// int j = col -1;
// assert(arr);
// //printf("arr=%d\narr+1 = %d\n",arr,arr+1);
// while(i=0)
// {
// if(arr[i*col+j] == key)
// {
// printf("存在\n");
// return 0;
// }
// else if(arr[i*col+j] > key)
// {
// j--;
// }
// else
// {
// i++;
// }
// }
// printf("不存在\n");
// return 0;
//}
//
//
//int main()
//{
// int arr[][4] = { {1,4,7,10},
// {9,12,15,18},
// {17,20,23,26},
// {25,28,31,34},
// };
//
// int key = 0;
// printf("请输入要查找的数:> ");
// scanf("%d",&key);
// //Seek(arr,4,key);
// //printf("%d\n",*(int*)arr+1);
// //printf("arr=%d\n(int*)arr=%d\n&arr=%d",arr,(int*)arr,&arr);
// Seek((int*)arr,4,4,key);
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
作业19
模拟strcpy函数
//#include
//char *my_strcpy(char *dst, const char *src)
//{
// char *p = dst;
// assert(dst);
// assert(src);
// while(*dst++ = *src++)
// {
// ;
// }
// return dst;
//}
//
//int main()
//{
// char *cp = "abcde12345";
// char arr[20];
// printf("%s\n",cp);
// my_strcpy(arr,cp);
// printf("%s\n",arr);;
// return 0;
//}
模拟strcat(字符串拼接)
//#include
//char *my_strcat(char *dst, const char *src)
//{
// char *p = dst;
// assert(dst);
// assert(src);
// while(*dst) //while(*dst++) 错误的 //while((*dst)++) 错误的
// {
// dst++;
// }
// while(*dst++ = *src++)
// {
// ;
// }
// return p;
//}
//
//int main()
//{
// char arr[20] = "abcde";
// char *cp = "456789";
// printf("%s\n",arr);
// my_strcat(arr,cp);
// printf("%s\n",arr);
// return 0;
//}
模拟strstr(判断字符串1是不是字符串2的子串)
//#include
//#include
//char *my_strstr(const char *dst,const char *src)
//{
// const char *end = dst + strlen(dst) - strlen(src) + 1; //优化的地方
// const char *d = dst;
// assert(dst);
// assert(src);
// while(d < end)
// {
// const char *p = d;
// const char *s = src;
// while(*s)
// {
// if(*p == *s)
// {
// p++;
// s++;
// }
// else
// {
// break;
// }
// }
// if(*s == '\0')
// {
// return d;
// }
// d++;
// }
//
//}
//#include
//char *my_strstr(const char *dst, const char *src)
//{
// char *d = dst;
// assert(dst);
// assert(src);
// while(d)
// {
// const char *p = d;
// const char *s = src;
// while((*p != '\0') && (*s != '\0') && (*p == *s))
// {
// s++;
// p++;
// }
// if(*s == '\0')
// {
// return d;
// }
// d++;
// }
//}
//
//int main()
//{
// char *s = "abcdefg";
// char *p = "cdef";
// //char *ch = "higk";
// char * ret = my_strstr(s,p);
// //char * ret = my_strstr(s,ch);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strchr
//
//#include
//char *my_strchr(const char *dst, char c)
//{
// assert(dst);
// while((*dst != c) && (*dst != '\0'))
// {
// dst++;
// }
// return *dst == c ? dst:NULL;
//}
//
//int main()
//{
// char *s = "abcdef";
// char c = 'g';
// char *ret = my_strchr(s, c);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strcmp
//#include
//int my_strcmp(const char *dst, const char *src)
//{
// assert(dst);
// assert(src);
// while(*dst != '\0' && *src != '\0')
// {
// if(*dst == *src)
// {
// dst++;
// src++;
// }
// else if(*dst > *src)
// {
// return 1;
// }
// else
// {
// return -1;
// }
// }
// if(*dst != '\0')
// {
// return 1;
// }
// if(*src != '\0')
// {
// return -1;
// }
// return 0;
//}
//#include
//int my_strcmp(const char *dst, const char *src)
//{
// int ret = 0;
// assert(dst);
// assert(src);
// while(!(ret = *(unsigned char *)dst - *(unsigned char *)src) && *src)
// {
// dst++;
// src++;
// }
// if(ret > 0)
// {
// ret = 1;
//
// }
// else
// {
// return -1;
// }
// return ret;
//}
//
//int main()
//{
// char *ch = "abcde";
// char *cp = "abcdef";
// int ret = my_strcmp(ch,cp);
// printf("%d\n",ret);
// return 0;
//}
模拟实现memcpy
//#include
//#include
//char *my_memcpy(void *dst, const void *src, int count)
//{
// char *d = dst;
// const char *s = src;
// assert(dst);
// assert(src);
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
// return dst;
//}
//
//int main()
//{
// char p[] = "abcdef";
// char arr[10];
//
// //printf("%d\n",strlen(s));
// my_memcpy(arr,p,sizeof(p));
// printf("%s\n",arr);
// return 0;
//}
模拟实现memmove
//#include
//#include
//void *my_memmove(void *dst, const void *src, int count)
//{
// char *d = dst;
// const char *s = src;
// assert(dst);
// assert(src);
//
//if(s < d && s+count >d)
//{
// d = d + count -1;
// s = s + count -1;
// while(count--)
// {
// *d = *s;
// --d;
// --s;
// }
//}
//else
//{
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
//}
// if(d <= s || s+count <= d) //错误的 if(d <= s && s+count <= d)
// {
// while(count--)
// {
// *d = *s;
// ++d;
// ++s;
// }
// }
// else
// {
// d = d + count -1;
// s = s + count -1;
// while(count--)
// {
// *d = *s;
// d--;
// s--;
// /*--s;
// --d;*/
// }
// }
//
// return dst;
//}
//
//int main()
//{
// char ch[64]= "abcdefghijk";
// my_memmove(ch,ch+1,strlen(ch));
// printf("%s\n",ch);
// return 0;
//}
作业20
//int *p; --> 指针
//int arr[5]; --> 数组
//int *p[5]; --> 指针数组
//int (*p)[5]; --> 数组指针
//int *((*p)[5]); --> 指针数组的指针
//int *((*p)[10])[5]; --> 指针数组指针的数组
//int (*p[10])[5]; --> 数组指针数组
//int *(*p[5])[5]; --> 数组指针数组的指针
//
//
//int test() --> 函数的声明
//int *ptest() -->指针函数 //是否存在？ 是
//int (*ptest)() --> 函数指针
//
//(void (*)() 函数指针 --> void(*)()0 将0强转为函数指针 -->
//(void(*)()0) 对0这个函数指针解引用 --> (*(void(*)()0)() -->
//调用函数，这个函数为:无返回类型参数为空的函数
//
//void(*signal(int,void(*)(int)))(int);
//
//typedef void(*pfun_t)(int); -->定义了一个 函数指针类型
//返回值为void 参数为int 的函数指针类型
//
//pfun_t signal(int, pfun_t) --> 返回值为 函数指针 参数为 int和函数指针 的函数声明
//
//int (*p[5])() -->函数指针数组
//int *p[5]() --> 不存在这样的东西
//int (*)()p[5] -->错误的,语法错误
//
//int ((*p)[5])() -->数组指针函数
//int (*(*p)[5])() -->函数指针数组指针
//int (*(*p[10])[5])() -->函数指针数组指针的数组
求一个整数存储在内存中的二进制中1的个数
//int Count(int num)
//{
// int count = 0;
// while(num)
// {
// count++;
// num &= (num-1);
// }
// return count;
//}
//
//int main()
//{
// int a = 0;
// int ret = 0;
// scanf("%d",&a);
// ret = Count(a);
// printf("%d\n",ret);
// 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 input = 1; //初值不能为零
// int x = 0;
// int y = 0;
// int ret = 0;
// int (*p[5])(int x, int y) = {0,add,sub,mul,div}; //转移表
// while(input)
// {
// printf("*************************\n");
// printf("***1.add 2.sub***\n");
// printf("***3.mul 4.div***\n");
// printf("*************************\n");
// printf("请选择: ");
// scanf("%d",&input);
// if((input>0) && (input<5))
// {
// printf("请输入操作数 ");
// scanf("%d%d",&x,&y);
// ret = (*p[input])(x, y);
// }
// else
// {
// printf("选择错误");
// break;
// }
// printf("ret = %d\n",ret);
// printf("\n");
// printf("\n");
// printf("\n");
// printf("-------------------------\n");
// }
// return 0;
//}
回调函数
模拟实现qsort（采用冒泡法）
//int int_cmp(const void *x, const void *y)
//{
// int *a = (int *)x;
// int *b = (int *)y;
// return *a > *b ? 1 : *a < *b ? -1 : 0;
//}
//
//void swap(void *x, void *y,int size)
//{
// char *a = (char *)x;
// char *b = (char *)y;
// while(size--)
// {
// *a ^= *b;
// *b ^= *a;
// *a ^= *b;
// a++; //不能少
// b++;
// }
//}
//
//void bubble(void *arr, int count, int size, int(*cmp)(void *x, void *y))
//{
// int i = 0;
// int j = 0;
// int flag = 0;
// for(i = 0;i 0) //注意最后的>0
// {
// flag = 1;
// swap((char *)arr + j*size, (char *)arr + (j+1)*size, size);
// }
// }
// if(0 == flag)
// {
// break;
// }
// }
//}
//
//void print_arr(int arr[10], int sz)
//{
// int i = 0;
// for(i=0;i
//#include
//
//char *my_strncat(char *dst, const char *src, int num)
//{
// char *ret = dst;
// assert(dst);
// assert(src);
// while(*dst)
// {
// ++dst;
// }
// while(num--)
// {
// *dst = * src;
// dst++;
// src++;
// }
// return ret;
//}
//
//int main()
//{
// char arr[64] = "abcdefg";
// char *ch = "hijklmn";
// int sz = strlen(ch);
// char *ret = my_strncat(arr,ch,sz);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strncpy
//#include
//#include
//char *my_strncpy(char *dst, const char *src, int num)
//{
// char *ret = dst;
// assert(dst);
// assert(src);
// while(num--)
// {
// *dst = *src;
// dst++;
// src++;
// }
// return ret;
//}
//
//int main()
//{
// char arr[64];
// char *ch = "opqrstuvwxyz";
// int sz = strlen(ch) + 1; //需要手动加\0
// char *ret = my_strncpy(arr,ch,sz);
// printf("%s\n",ret);
// return 0;
//}
模拟实现strncmp
//#include
//int my_strncmp(const char *p, const char *q, int num)
//{
// assert(p);
// assert(q);
// while(num--)
// {
// if(*p > *q)
// {
// return 1;
// }
// else if(*p < *q)
// {
// return -1;
// }
// else
// {
// p++;
// q++;
// }
// }
// return 0;
//}
//
//int main()
//{
// char *ch = "abcde";
// char *cp = "abcdef";
// int ret = my_strncmp(ch,cp,6);
// printf("%d\n",ret);
// return 0;
//}
//int main()
//{
// int i = 0;
// printf("请输入要转换的十进制数： \n");
// scanf("%d",&i);
// printf("该数转换为十六进制数为：%x\n",i );
// return 0;
//}
//int *f1(void)
//{
// int x = 10;
// return &x;
//}
//
//int main()
//{
// int *ret = f1();
// printf("%d\n",*ret);
// return 0;
//}
//struct B
//{
// int a;
//};
//
//typedef struct A
//{
// int a;
// char b;
// double c;
// float d;
// struct A *obj;
//}x;
//struct B
//{
// int a;
// char b;
//}*p,arr[20];
//struct B;
//struct A
//{
// int x;
// struct B *b;
//};
//
//struct B
//{
// int y;
// struct A *a;
//};
//struct A
//{
// char a;
// int c;
// char b;
//};
//
//
//int main()
//{
// printf("%d\n",sizeof(struct A));
// //struct point p2 = {1,2};
// //p1.x = 1;
// //p1.y = 2;
// //p1 = {1,2}; //错误
// //x obx;
// //printf("%#p\n",&x);
// //printf("%#p\n",&(x.a));
// //printf("%#p\n",&(x.b));
// //printf("%#p\n",&(x.c));
// //printf("%#p\n",&(x.d));
// //struct A *p = &x;
// //x.a = 10;
// //x.b = 'A';
// //
// //p->a = 300;
// //p->b = 'C';
// //(*p).a = 20;
// //(*p).b = 'B';
// //p = &x; //错误的
// return 0;
//}
将8个比特为的某一位改为flag
//void fun(int i, int step, int flag)
//{
// int j = 0;
// for(j = 7;j>=0;j--)
// {
// if(j == (8-step+1))
// {
// if(((i >> j) & 1) == flag)
// {
// printf("%d",(i >> j) & 1);
// }
// else
// {
// printf("%d",!((i >> j) & 1));
// }
// }
//
// else
// {
// printf("%d",(i >> j) & 1);
// }
// }
//}
//
//
//int main()
//{
// char a = 5;
// fun(a,5,1);
// return 0;
//}
编写函数：
unsigned int reverse_bit(unsigned int value);
这个函数的返回 值value的二进制位模式从左到右翻转后的值。
如：
在32位机器上25这个值包含下列各位：
00000000000000000000000000011001
翻转后：（2550136832）
10011000000000000000000000000000
程序结果返回：
2550136832
//typedef unsigned int unit;
//#include
//unsigned int reverse_bit(unsigned int value)
//{
// int i = 0;
// unsigned int num = 0;
// for(i=0;i<32;i++)
// {
// //num = (unit)(num + ((value >> i) & 1) * pow(2,32-i-1));
// num |= ((value >> i) & 1) << (31 - i); //效率更高 (拿到那一位将它左移到对应位，进行或等就会得到翻转的值)
//
// }
// return num;
//}
//
//int main()
//{
// unsigned int i = 0;
// unsigned int ret = 0;
// scanf("%d",&i); //不能写成 scanf("%u",%i); 程序会崩溃
// ret = reverse_bit(i);
// printf("%u\n",ret);
// //printf("%d\n",sizeof(unit));
// return 0;
//}
不使用（a+b）/2这种方式，求两个数的平均值
方法一
//int Average(int x, int y)
//{
// return y+(x-y)/2;
//}
方法二
//00001010 10
//00010100 20
//
//00000000 &
//00011110 ^
//00001111 ^ >>1
首先，&得到的数字位，只有两个1才得到1，就是进位的1，
而本该向前进一位的1待在了本位。实际上
应该让得到的结果左移1（让进位的1进到合适的位置），
然后再右移1（除以2），得到进位的平均数。
然后，^得到的数字位，实际得到的是本位得到的结果（不包括进位），
让他右移1，得到本位的平均数。
两个平均数相加，得到整个数完整的平均数。
//#include
//int Average(int x, int y)
//{
// return (x & y) + ((x ^ y) >> 1); //(x&y) x和y相同位的平均值 (x^y)>>1 x和y不同位的平均值
//}
//
//int main()
//{
// int a = 25;
// int b = 15;
// int ret = 0;
// ret = Average(a,b);
// printf("%d\n",ret);
// return 0;
//}
编程实现：
一组数据中只有一个数字出现了一次。其他所有数字都是成对出现的。
请找出这个数字。（使用位运算）
//int look_out(int *a, int len)
//{
// int i = 0;
// int ret = 0;
// for(i=0;i
区间位左闭右闭
//int banary_search(int arr[], int len, int num)
//{
// int left = 0;
// int right = len - 1; //[ ]左闭右闭的情况
//
// while(left <= right) 要小于等于
// {
// int mid = left + ((right - left) >> 1);//
// if(arr[mid] == num)
// {
// return mid;
// }
// else if(arr[mid] < num)
// {
// left = mid + 1; //保证左闭
// //mid = left + ((right - left)/2);
// //mid = left + ((right - left) >> 1);
// //mid = (left & right) + ((left ^ right) >> 1);
// }
// else
// {
// right = mid - 1; //保证右闭
// //mid = left + ((right - left)/2);
// //mid = left + ((right - left) >> 1);
// //mid = (left & right) + ((left ^ right) >> 1);
// }
// }
// return -1;
//}
区间为左闭右开
//int banary_search(int *arr, int len, int num)
//{
// int left = 0;
// int right = len; // [ ) 左闭右开
//
// while(left < right) //
// {
// int mid = (left & right) + ((left ^ right) >> 1);//
//
// if(arr[mid] == num)
// {
// return mid;
// }
// else if(arr[mid] < num)
// {
// left = mid + 1; //
// //mid = (left & right) + ((left ^ right) >> 1);
// }
// else
// {
// right = mid;
// //right = mid - 1; //如果恰巧middle-1就是查找的元素,那么就会找不到这个元素
// //mid = (left & right) + ((left ^ right) >> 1);
// }
// }
// return -1;
//}
递归的方式 (时间复杂度O(log2 n) 空间复杂度O(n))
//int banary_search(int arr[], int left, int right, int num)
//{
// int mid = (left & right) + ((left ^ right) >> 1);
// if(left > right)
// {
// return -1;
// }
// else
// {
// if(arr[mid] == num)
// return mid;
// else if(arr[mid] < num)
// banary_search(arr,mid+1,right,num); //
// else
// banary_search(arr,left,mid-1,num); //
// }
//}
//
//
//int main()
//{
// int arr[] = {1,2,3,4,5,6,7,8,9,10};
// //int len = sizeof(arr)/sizeof(arr[0]);
// int left = 0;
// int right = sizeof(arr)/sizeof(arr[0])-1;
// int ret = banary_search(arr,left,right,5);
// //int ret = banary_search(arr,len,5);
// printf("%d\n",ret);
// return 0;
//}
斐波那契数列(循环方式)(时间复杂度 O(n) 空间复杂度 O(1))
//int fibonacci_sequence(int n)
//{
// int a = 1;
// int b = 1;
// int c = 1;
// while(n>2)
// {
// c = a + b;
// a = b;
// b = c;
// --n;
// }
// return c;
//
//}
//0 1 1 2 3 5 8 13 21 34 55
递归方式(时间复杂度O(2^n) 空间复杂度O(n))
//int fibonacci_sequence(int n)
//{
// if(n<3)
// return 1;
// return fibonacci_sequence(n-1)+fibonacci_sequence(n-2);
//}
//
//int main()
//{
// printf("%d\n",fibonacci_sequence(7));
// return 0;
//}
#define _CRT_SECURE_NO_WARNINGS 1
//#include
猜数字游戏
#include
#include
//#include
//#include
//enum Option
//{
// EXIT,
// PLAY,
//};
//
//void menu()
//{
// printf("*************************\n");
// printf("*** 1.play 0.exit ***\n");
// printf("*************************\n");
//
//}
//
//void game()
//{
// int ret=0;
// int num=0;
// ret = rand()%100+1;
// while(1)
// {
// printf("请猜数字; ");
// scanf("%d",&num);
// if(num == ret)
// {
// printf("恭喜你，猜对了\n");
// break;
// }
// else if(num>ret)
// {
// printf("猜大了\n");
// }
// else
// {
// printf("猜小了\n");
// }
// }
//}
//
//int main()
//{
// int input=0;
// srand((unsigned int)time(NULL));
// do
// {
// menu();
// printf("请选择： ");
// scanf("%d",&input);
// switch(input)
// {
// case 1:
// game();
// break;
// case 0:
// break;
// default:
// printf("选择错误\n");
// break;
// }
// }
// while (input);
//
//return 0;
//}
用2分法查找数组里面的元素，找到时返回该元素下标
//int main()
//{
// int key = 10;
// int arr[] = {0,1,2,3,4,5,6,7,8,9};
// int left = 0;
// int right = sizeof(arr)/sizeof(arr[0])-1;
// int mid = left+(right-left)/2;
//
// while(left<=right)
// {
// mid=left+(right-left)/2;
// if(arr[mid]==key) // 切记: 比较的时候不能写为 if(arr==key)
// {
// printf("找到了\n");
// printf("%d\n",mid);
// break;
// }
// else if(arr[mid]right)
// {
// printf ("没找到\n");
// }
//
//return 0;
//}
模拟用户登录密码只有3次输入机会
//#include
//int main()
//{
// int i = 0;
// char passwed [10] = {0};
//
// while(i<3) //或者用for(i=0;i<3;i++)则去掉后面的i++。continue有没有不影响
// {
// printf("请输入密码\n：");
// scanf("%s",&passwed); // 切记 ：前俩句不能放在循环外部。一定要放在循环内部，因为每次都要输入密码再判断。
// if(0 == strcmp(passwed,"123456"))
// {
// printf("登陆成功!\n");
// break;
// }
// else
// {
// printf("密码错误!\n");
// i++;
// continue; //结束本次循环，进入下次循环的判断部分
// }
// }
// if(i == 3)
// {
// printf("退出系统！");
// }
//
//return 0;
//}
计算有几位
// int main()
// {
// int i = 0;
// int m = 0;
// int bit = 1;
// scanf("%d",&i);
// m=i;
// while(m/10)
// {
// bit++;
// m=m/10;
// }
// return 0;
// }
写一个函数返回参数二进制中 1 的个数
i大于15和负数 没有输出
//int main()
//{
// int i = 0;
// int count = 0;
// scanf("%d",&i);
// while(i)
// {
// if(i%2 == 1)
// {
// count++;
// i=i/2;
// }
// }
// printf("%d",count);
//return 0;
//}
//int main()
//{
// int num = 0;
// int i = 0;
// int count = 0;
// scanf("%d",&num);
// for(i=0;i<32;i++)
// {
// if(((num>>i) & 1) == 1)
// {
// count++;
// }
// }
// printf("%d",count);
// return 0;
//}
//int main()
//{
// int num = 0;
// int count = 0;
// scanf("%d",&num);
// while(num)
// {
// count++;
// num = num & (num-1);
// }
// printf("%d",count);
// return 0;
//}
获取一个数二进制序列中所有的偶数位和奇数位，分别输出二进制序列
//int main()
//{
// int i = 0;
// int j = 0;
// int a = 0;
// scanf("%d",&i);
// printf("奇数位\n");
// for(j=0;j<31;j+=2)
// {
// //先打印奇数位
// i=i >> j;
// a=i & 1;
// printf("%d",a);
// }
// //打印偶数位
// printf("\n");
// printf("偶数位\n");
// for(j=1;j<32;j+=2)
// {
// i = i >> j;
// a = i & 1;
// printf("%d",a);
// }
//return 0;
//}
//输出一个整数的每一位
//int main ()
//{
// int i = 0;
// int tmp = 0;
// int bit = 1;
// scanf("%d",&i);
//
// // 计算这个数有几位
// tmp = i;
// while(tmp/10)
// {
// bit++;
// tmp=tmp/10;
// }
// // 取下每一位的数字
// while(i%10)
// {
// printf("%d\n",i%10);
// i=i/10;
// }
//
//return 0;
//}
编程实现：
两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同？
//int main()
//{
// int m = 0;
// int n = 0;
// int i = 0;
// int count = 0;
// scanf("%d%d",&m,&n);
// m=m^n;
// for(i=0;i<32;i++)
// {
// if(((m>>i) &1 ) == 1)
// {
// count++;
// }
// }
// printf("%d",count);
//return 0;
//}
用函数打印自己可以控制行列的乘法口诀表
//void Mul(int x, int y,int n)
//{
// for(x=1;x<=n;x++)
// {
// for(y=1;y<=x;y++)
// {
// printf("%2d*%2d=%2d ",x,y,x*y); //不要写成 printf("%2d*%2d=%2d",x*y);这样打印的是i*随机值
// }
// printf("\n");
// }
//}
//
//
//int main()
//{
// int i = 0;
// int j = 0;
// int n = 0;
// scanf("%d",&n);
// Mul (i,j,n);
//return 0 ;
//}
用函数的方式交换两个数
//void Swap (int *p1, int *p2)
//{
// int tmp = 0;
// tmp = *p1;
// *p1 = *p2;
// *p2 = tmp;
// printf("交换a和b:");
// printf("\n");
// printf("a=%d\nb=%d",*p1,*p2);
//}
//
//
//int main ()
//{
// int a = 0;
// int b = 0;
// printf("请输入a和b:");
// printf("\n");
// scanf("%d%d",&a,&b);
// Swap(&a,&b);
//
//return 0;
//}
用函数的方式判断是不是闰年
//void Year (int x)
//{
// if((x%4==0)&&(x%100 != 0)||(x%400==0))
// {
// printf("是闰年\n");
// }
// else
// {
// printf("不是闰年\n");
// }
//}
//
//
//int main()
//{
// int i = 0;
// printf("请输入年份:");
// scanf("%d",&i);
// Year (i);
//return 0;
//}
求两个数的最小公倍数
//int main ()
//{
// int a = 0;
// int b = 0;
// int c = 0;
// int d = 0;
// int tmp = 0;
// scanf("%d%d",&a,&b);
// c = a;
// d = b;
// //先求最大公约数
// while(c%d)
// {
// //if(c%d != 0)
// //{
// tmp = c%d;
// c = d;
// d = tmp;
// // }
// }
// //求最小公倍数
// a = a*b/d;
// printf("%d",a);
//return 0;
//}
日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。以下为4个嫌疑犯的供词。
A说：不是我。
B说：是C。
C说：是D。
D说：C在胡说
已知3个人说了真话，1个人说的是假话。
现在请根据这些信息，写一个程序来确定到底谁是凶手。
//int main()
//{
// int killer = 0;
// for(killer = 'a'; killer<='d'; killer++)
// {
// if(3==(killer != 'a')
// +(killer == 'c')
// +(killer == 'd')
// +(killer != 'd'))
// {
// printf("%c\n",killer);
// }
// }
//return 0;
//}
//打印杨辉三角
//int main()
//{
// int arr[10][10]={0};
// int i = 0;
// int j = 0;
// int sz = 10;
//
// for(i=0;i1)&&(j>0))
// {
// arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
// }
// }
//
// }
//
// for(i=0;i1&&j>0)
// {
// arr[i][j] = arr[i-1][j-1]+arr[i-1][j];
// }
// }
//
// for(j=0;j
在这里插入代码片
