练习
写一个函数可以判断一个数是不是素数
素数：只能被1和自己整除的数

代码演示：

define _CRT_SECURE_NO_WARNINGS

include<stdio.h>

include<math.h>

int is_prime(int n)
{

int j = 0;
for (j = 2; j <= sqrt(n); j++)//函数要写头文件
{
    if (n % j == 0)
        return 0;
}
return 1;

}
int main()
{

int count = 0;
int i = 0;
for (i = 101; i <= 200; i+=2)//偶数不用考虑了
{
    if (is_prime(i))
    {
        printf("%d ",i);
        count++;
    }
        
}
printf("\n共有%d个素数", count);
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
运行结果：

写一个函数判断一年是不是闰年
判断闰年的规则：能被4整除，并且不被100整除或能被400整除

代码演示:

define _CRT_SECURE_NO_WARNINGS

include<stdio.h>

int is_leap_year(int y)//是闰年返回1
{

 if ((y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0))
     return 1;
 else 
     return 0;

}
int main()
{

int year= 0;
for (year = 1000;year<= 2000; year++)
{
    if (is_leap_year(year))
    {
        printf("%d ",year);
        
    }        
}
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
运行结果：

写一个函数，实现一个整形有序数组的二分查找
代码演示：

define _CRT_SECURE_NO_WARNINGS

include<stdio.h>

int binary_search(int arr[], int k, int sz)
{

int left = 0;
int right = sz - 1;

while(left<=right)
{
    int mid = left + (right - left) / 2;
    if (arr[mid] < k)
    {
        left = mid + 1;
    }
    else if (arr[mid] > k)
    {
        right = mid - 1;
    }
    else
    {
        return mid;//找到了，返回下标mid
    }
}
return -1;//没有找到

}
int main()
{

int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int k = 7;
int sz = sizeof(arr) / sizeof(arr[0]);
int ret = binary_search(arr, k,sz);
if (ret == -1)
    printf("找不到\n");
else
    printf("找到了，下标是：%d\n", ret);
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
因为数组下标从0开始，所以没有找到时不能返回0

运行结果：

再来看这段代码：
我们不传参数sz到函数binary_search中去，直接在函数中写：int sz = sizeof(arr) / sizeof(arr[0]);
结果是什么都找不到

define _CRT_SECURE_NO_WARNINGS

include<stdio.h>

int binary_search(int arr[], int k)
{

int sz = sizeof(arr) / sizeof(arr[0]);
int left = 0;
int right = sz - 1;
while(left<=right)
{
    int mid = left + (right - left) / 2;
    if (arr[mid] < k)
    {
        left = mid + 1;
    }
    else if (arr[mid] > k)
    {
        right = mid - 1;
    }
    else
    {
        return mid;
    }
}
return -1;//因为数组下标从0开始，所以这里不能返回0

}
int main()
{

int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int k = 7;
int ret = binary_search(arr, k);
if (ret == -1)
    printf("找不到\n");
else
    printf("找到了，下标是：%d\n", ret);
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
运行结果：

分析: 数组传参时为了不浪费空间，只传过去数组的首地址，那这就是一个指针，就不需要一个很大的数组了，所以arr本质上是一个指针变量，所以binary_search函数访问和使用的数组，实际上还是主函数中的数组，因此，sizeof (arr)的值为4，sizeof arr[0]的值为4，得到sz=1，那么right=0，循环直接结束，自然找不到

写一个函数，每调用一次这个函数，就会将num的值增加1
代码演示：

define _CRT_SECURE_NO_WARNINGS

include<stdio.h>

int Add(int *p)
{

(*p)++;

}
int main()
{

int num = 0;
Add(&num);
printf("%d\n", num);//1
Add(&num);
printf("%d\n", num);//2
return 0;

}

运行结果：

下期预告:

函数的嵌套调用和链式访问
函数的声明和定义
函数递归