1 对一个一维数组进行按照元素的升序大小进行排序，冒泡排序法
2 随机生成一个有10个元素的一维数组，并找出极值
3 将一个一维数组中n个整数按相反顺序存放
4 用指针方法对10个整数按照从大到小顺序排序，冒泡排序法
5 用随机数生成一个数组，写一个函数查找最小的，并返回最小数的地址。在主函数中打印出来最小数
6 不改变原有的一维数组排序，使用指针数组，进行排序，冒泡排序法
7 一维数组的逆转
8 有 N个数已按由小到大的顺序排好，要求输入一个数， 把它插入到原有序列中，而且仍然保持有序
9 用选择法对10个整数由大到小排序
10 用筛选法求 2到 100之间的素数。方法如下：首先 2是素数，凡 2 的倍数都不是素数，于是把这些数从数表中筛去， 2以后没有被筛去的第一个数是 3， 然后把 3的倍数都从数表中筛去， 3以后没被筛去的第一个数是 5，然后把 5 的倍数都从数表中筛去。如此下去，直到遇到某数 K（≤ N），其后没有数可筛选为止， 这时保留下的未被筛去的数就是 2到 N的素数
11 有17个人围成一圈（编号为0～16），从第 0号的人开始从 1报数， 凡报到 3的倍数的人离开圈子，然后再数下去，直到最后只剩下一个人为止。 问此人原来的位置是多少号？
可以使用数组解决，也可以使用循环链表解决。这里使用数组解决。
12 打印所有不超过 n（ n<256）的其平方具有对称性的数（也称回文数）。
13 求N个数中的最大值，最大值出现的次数，然后求出次大值（次大值一定存在）。
14 圆盘上有如下图所示的二十个数，请找出哪四个相邻数之和为最大，并指出它们的起始位置及最大和的值。
15 将一个一维数组中的偶数依次交换。例如有8个元素， 若其中第1、4、5三元素是偶数时应按下图交换。
16 有n个整数，编程序将前面的各个数依次向后移动k个位置，最后k个数移到最前边的k个位置（见下图，其中n=8，k=3）。
1 2 3 4 5 6 7 8
6 7 8 1 2 3 4 5
思考: 程序中不许引入其它数组。
第一次，8 7 6 4 5 3 2 1
第二次，6 7 8 4 5 3 2 1
第三次，6 7 8 1 4 5 3 2
第四次，6 7 8 1 2 4 5 3
第五次，6 7 8 1 2 3 4 5
17 自然数N一般写成如下形式:
N=dk dk-1 d1 （d1～dk 均是十进制数字）
如果di+1 >di (i=k-1,k-2,...,1)，则称N是严格降序数；如果di+1
18 已知A是有30个元素的整型数组，编写一个对A[I1]到A[I2]（I1≤I2）之间的元素排序的函数（从大到小排序）。请调用上述函数先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出。再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出。
要求：1) 输入输出均由主函数实现。
2) 输出时每10个元素占1行。
19 编写求最大平台问题的程序。
有n个整数a1,a2, ... an, 若满足a1≤a2≤ ... ≤ an ，则认为在这n个数中有最大平台。在这种情况下，若n个数互不相同，则最大平台值为1，若在n个数中最多有连续m个整数的值相等，则最大平台值为m。
例如: n=10时
1,2,3,4,5,6,6,7,4,5 无最大平台
1,1,2,2,2,2,2,2,2,2 最大平台值为8
1,1,2,2,2,3,3,4,4,5 最大平台值为3
0,1,2,3,4,5,6,7,8,9 最大平台值为1
20 某桔农家共有2520只桔子, 父亲要将它们分给六个儿子，其分法如下：父亲先将2520只桔子分给六个儿子, 然后说：“老大，把你分到的桔子的八分之一给老二；老二拿到以后，连同原来的桔子分出七分之一给老三；老三拿到以后，连同原来的桔子分出六分之一给老四；老四拿到以后，连同原来的桔子分出五分之一给老五；老五拿到以后，连同原来的桔子分出四分之一给老六；老六拿到以后，连同原来的桔子分出三分之一给老大”。这样分完之后，六个儿子手里的桔子正好一样多。问六个儿子原先分到的桔子各是多少只？
21 间隔元素排序。用随机函数产生25个[25,75]之间的整数， 把它送到一维数组M中。要求对M[I],M[I+J],M[I+2*J],…这些元素按从小到大的顺序排序。J的值由键盘输入，I从1到J变化。实际上是以J为间隔排了J个对列，每个对列中从小到大排序。
22 求阶乘N!。
设输入的N最大可使N!达到100位，要求打印出全部有效数字。方法如下：用数组M[100]代表一个100位的数。M[1]代表最高位，M[100] 代表最低位。先对M[100]置1，其余各元素置零，然后从1到N进行累乘。同通常作乘法一样，数组M与I（1≤I≤N）相乘时，从低位数乘起，乘积大于9时进到上一位去，然后将结果打印（从头一个不等于零的位开始）。
23 编写“N个人放鞭炮问题的程序”。
N个人同时刻开始放鞭炮， 第一个人每隔T1秒放一次，第二个人每隔T2秒放一次，...第N个人每隔Tn秒放一次。每个人各放M个鞭炮。问总共能听到多少次鞭炮声。
24 十个数字组成完全平方数。
把0、1、2、3、4、5、6、7、8、9十个数字分别组成一个一位数，一个二位数，一个三位数和一个四位数，使它们都是完全平方数（其平方根是整数），共有几种方法? 每种方法的结果是什么? （每个数字只允许用一次）。下边就是一种填法：
１ （ １ ）
３６ （ ６ ）
７８４ （ ２８ ）
９０２５ （ ９５ ）
-----------------------------二维数值
9 对一个二维数组进行转置
10 打印杨辉三角形，包括直角三角形和等腰三角形
11 有一个班，3个学生，各学4门课，计算总平均分以及第n个学生的成绩。查找有一门以上课程不及格的学生，输出该学生的所有成绩
12 打印如下形式的杨辉三角形
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
输出前10行，从 0行开始，分别用一维数组和二维数组实现
13 把一个二维实型数组a按照第0列的元素进行排序（由小到大排序，用起泡法）。例如：如果a[i][0]大于a[i+1][0]，则i行与i+1行中所有元素都要进行对换
14 编程产生如下形式的方阵。
1 2 2 2 2 2 1
3 1 2 2 2 1 4
3 3 1 2 1 4 4
3 3 3 1 4 4 4
3 3 1 5 1 4 4
3 1 5 5 5 1 4
1 5 5 5 5 5 1
要求：不允许使用键盘输入语句和静态赋值语句，尽量少用循环。
15 找出 M×N 数组中所有不相邻元素，并求出它们的和（相邻的数：前一个是偶数，后一个是素数）。
16 打印魔方阵。所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。例如：三阶魔方阵为
8 1 6
3 5 7
4 9 2
要求打印由 1到的自然数构成的魔方阵。
提示：魔方阵中各数的排列规律如下：
⑴ 将“1”放在第一行中间一列；
⑵ 从“2”开始直到n×n为止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1；
⑶ 如果上一个数的行数为1，则下一个数的行数为 n（指最下一行）；
⑷ 当一个数的列数为 n，下一个数的列数应为1，行数减1；
⑸ 如果按上面规则确定的位置已有数，或上一个数是第 1行第 n列时， 则把下一个数放在上一个数的下面。
17 找规律，编程序打印6×6的矩阵:
1 2 3 5 8 13
1 4 9 17 30 51
1 6 19 45 92 173
. . .
18 已知M1是3×5的矩阵, M2是5×2的矩阵, 编程序求出M1与M2之积。
19 找规律填写N×N方阵。如N=8时, 其方阵为:
1 1 1 1 1 1 1 1
1 2 2 2 2 2 2 1
1 2 3 3 3 3 2 1
1 2 3 4 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 3 3 2 1
1 2 2 2 2 2 2 1
1 1 1 1 1 1 1 1
20 求N阶方阵（即N×N数组）中各条反斜线上的元素之和。如4×4数组共有7条反斜线：
注：求和时，请按斜线编号顺序显示求出的和。
21 编写程序，按照 1,2, ... , 28的顺序填一个7×7数组的左上角，程序的输出结果为：
1 2 4 7 11 16 22
3 5 8 12 17 23
6 9 13 18 24
10 14 19 25
15 20 26
21 27
28
22 二维数组排序。设有4×5的数组M，通过排序使M[1][1]≤M[1][2]≤...≤M[1][5]≤M[2][1]≤M[2][2]≤...≤M[2][5]≤...≤M[4][1]≤M[4][2]≤...≤M[4][5]。排序时不允许引入其它数组。
--------------------------------------------------------------
1 对一个一维数组进行按照元素的升序大小进行排序，冒泡排序法
1 #include
2
3 void sort(int * a, int len)
4 {
5 int i, j, t;
6 for (i = 0;i < len - 1;++i)
7 {
8 for (j = 0;j < len - 1 - i;++j)
9 {
10 if (a[j] > a[j + 1]) /* >表示升序 <表示降序 */
11 {
12 t = a[j];
13 a[j] = a[j + 1];
14 a[j + 1] = t;
15 }
16 }
17 }
18 }
19
20 main()
21 {
22 int a[6] = { 10,2,8,-8,11,0 };
23 int i = 0;
24
25 sort(a, 6);
26
27 for (i = 0;i < 6;++i)
28 {
29 printf("%d ", a[i]);
30 }
31 printf("\n");
32 }
2 随机生成一个有10个元素的一维数组，并找出极值
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6
7
8 main()
9 {
10 time_t ts;
11
12 srand((unsigned int)time(&ts));
13
14 int a[10];
15 int i;
16 int max;//用于保存最大值
17 int maxi;//用于保存最大值的下标
18 int min;
19 int mini;
20
21 for (i = 0;i < 10;i++)
22 {
23 a[i] = rand() % 100;
24 printf("%d,%x\n", a[i], &a[i]);
25 }
26
27 max = a[0];//假设第一个是最大的数
28 maxi = 0;//
29 min = a[0];//假设第一个是最小的数
30 mini = 0;//
31
32 for (i = 1;i < 10;i++)//选择比较
33 {
34 if (a[i] > max)
35 {
36 max = a[i];
37 maxi = i;
38 }
39 }
40
41 for (i = 1;i < 10;i++)//选择比较
42 {
43 if (a[i] < min)
44 {
45 min = a[i];
46 mini = i;
47 }
48 }
49
50 printf("最大值是%d，下标是%d\n", max, maxi);
51 printf("最小值是%d，下标是%d\n", min, mini);
52
53 system("pause");
54 }
3 将一个一维数组中n个整数按相反顺序存放
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 void change(int a[], int n)
7 {
8 int i;
9 int temp;
10
11 //数组没有副本机制，等价于直接操作原生数组
12 for (i = 0;i < n / 2;i++)//数据的循环对调
13 {
14 temp = a[i];//数组的交换
15 a[i] = a[n - 1 - i]; 16 a[n - 1 - i] = temp; 17 } 18 } 19 20 main() 21 { 22 int a[10] = { 1,2,3,4,5,6,7,8,9,0 }; 23 int i; 24 25 for (i = 0;i < 10;i++) 26 { 27 printf("%4d", a[i]); 28 } 29 30 change(a, 10); 31 printf("\n"); 32 33 for (i = 0;i < 10;i++) 34 { 35 printf("%4d", a[i]); 36 } 37 38 system("pause"); 39 }
4 用指针方法对10个整数按照从大到小顺序排序，冒泡排序法
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 void sort(int *p, int n)
7 {
8 int i, j;
9 int temp;
10
11 for (i = 0;i < n - 1;i++)
12 { 13 for (j = 0;j < n - 1 - i;j++) 14 { 15 if (*(p + j) < *(p + j + 1)) 16 { 17 temp = *(p + j);//交换数据实现冒泡 18 *(p + j) = *(p + j + 1); 19 *(p + j + 1) = temp; 20 } 21 } 22 } 23 } 24 25 main() 26 { 27 int a[11] = { 1,2,13,4,5,16,7,8,9,10,29 }; 28 int i; 29 30 for (i = 0;i < 11;i++) 31 { 32 printf("%4d", a[i]); 33 } 34 35 sort(a, 11); 36 printf("\n"); 37 38 for (i = 0;i < 11;i++) 39 { 40 printf("%4d", a[i]); 41 } 42 43 system("pause"); 44 }
5 用随机数生成一个数组，写一个函数查找最小的，并返回最小数的地址。在主函数中打印出来最小数
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6
7 int a = 100;
8 int b = 10;
9
10 //函数，返回一个地址，对于数组而言，函数参数调用没有副本机制，为了节约内存
11 int * mindata(int a[], int n)//查找最小数
12 {
13 int *p = NULL;//保存最小数的地址
14 int min = a[0];
15 p = &a[0];
16 int i; 17 18 for (i = 0;i < n;i++)//选择法，选择最小的 19 { 20 if (a[i] < min) 21 { 22 min = a[i];//min确保是最小的值 23 p = &a[i];//p指向最小数的地址 24 } 25 } 26 printf("min=%d\n", min); 27 return p; 28 } 29 30 main() 31 { 32 time_t ts; 33 srand((unsigned int)time(&ts)); 34 35 int a[10]; 36 int i; 37 int min = 0; 38 39 for (i = 0;i < 10;i++) 40 { 41 a[i] = rand() % 100; 42 printf("%d\n", a[i]); 43 } 44 int *p = mindata(a, 10); 45 46 //修改最小数 47 *p = 200; 48 49 printf("\n"); 50 //查看修改以后的数组 51 for (i = 0;i < 10;i++) 52 { 53 printf("%d\n", a[i]); 54 } 55 56 system("pause"); 57 }
6 不改变原有的一维数组排序，使用指针数组，进行排序，冒泡排序法
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 main()
7 {
8 const int num[5] = { 12000,200,300,900,400 };//只读数组
9 int *p[5] = { &num[0],&num[1],&num[2],&num[3],&num[4] };//构建指针数组，分别存储常量数组的每一个元素的地址
10 int i, j;
11 int **pp = NULL;
12 int *t;
13
14 printf("原有数组\n"); 15 for (i = 0;i < 5;i++)//下标循环的方式 16 { 17 printf("%d\n", num[i]); 18 } 19 printf("\n"); 20 21 printf("排序以前\n"); 22 for (i = 0;i < 5;i++)//下标循环的方式 23 { 24 printf("%d,%d\n", *p[i], *(*(p + i)));//p[i]是一个地址，*p[i]取出内容 25 }//p[i]等价于*(p + i) 26 27 for (pp = p;pp < p + 5;pp++)//指针循环的方式，访问指针数组，需要二级指针 28 { 29 printf("%d\n", **pp); 30 } 31 32 for (i = 0;i < 5 - 1;i++)//剩下一个可以忽略，5-1 33 { 34 for (j = 0;j < 5 - 1 - i;j++) 35 { 36 if (*p[j] < *p[j + 1]) 37 { 38 t = p[j]; 39 p[j] = p[j + 1]; 40 p[j + 1] = t; 41 } 42 } 43 } 44 45 printf("原有数组\n"); 46 for (i = 0;i < 5;i++)//下标循环的方式 47 { 48 printf("%d\n", num[i]); 49 } 50 printf("\n"); 51 52 printf("排序以后\n"); 53 for (i = 0;i < 5;i++)//下标循环的方式 54 { 55 printf("%d,%d\n", *p[i], *(*(p + i)));//p[i]是一个地址，*p[i]取出内容 56 }//p[i]等价于*(p + i) 57 58 system("pause"); 59 }
7 一维数组的逆转
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 void rev(int a[], int n)
7 {
8 int i;
9 int temp;
10
11 for (i = 0;i < n / 2 - 1;i++)
12 {
13 temp = a[i];
14 a[i] = a[n - 1 - i];
15 a[n - 1 - i] = temp;
16 }
17 }
18
19 void rev1(int *a, int n)//数组名作为形式参数，就是一个指针，所以用指针也没问题
20 {
21 int i;
22 int temp;
23
24 for (i = 0;i < n / 2 - 1;i++)
25 {
26 temp = a[i];
27 a[i] = a[n - 1 - i];
28 a[n - 1 - i] = temp;
29 }
30 }
31
32 void rev2(int *a, int n)//指针循环
33 {
34 int i;
35 int temp;
36
37 for (i = 0;i < n / 2 - 1;i++)
38 {
39 temp = *(a + i);
40 *(a + i) = *(a + n - 1 - i);
41 *(a + n - 1 - i) = temp;
42 }
43 }
44
45 void rev3(int a[], int n)
46 {
47 int i;
48 int temp;
49
50 for (i = 0;i < n / 2 - 1;i++)
51 {
52 temp = *(a + i);
53 *(a + i) = *(a + n - 1 - i);
54 *(a + n - 1 - i) = temp;
55 }
56 }
57
58 main()
59 {
60 int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
61 int *p = a;
62 int i;
63 int n = sizeof(a) / sizeof(int);
64
65 for (i = 0;i < n;i++)
66 {
67 printf("%d\n", a[i]);
68 }
69
70 //rev(a, n);
71 //rev1(a, n);
72 //rev2(a, n);
73 rev3(p, n);
74
75 printf("逆序\n");
76 for (i = 0;i < n;i++)
77 {
78 printf("%d\n", a[i]);
79 }
80
81 system("pause");
82 };
8 有 N个数已按由小到大的顺序排好，要求输入一个数， 把它插入到原有序列中，而且仍然保持有序
1 #include
2
3 #define N 11
4
5 void printarr(int arr[], int n)//打印数组
6 {
7 int i;
8
9 for (i = 0; i < n; i++)
10 {
11 printf("%4d", arr[i]);
12 }
13
14 printf("\n");
15 }
16
17 main()
18 {
19 int arr[N] = { 1,2,3,4,5,7,8,9,10,11 };
20 int num = 6;//要插入的数
21 int i;
22 int j;
23
24 printarr(arr, N - 1);//打印数组
25
26 for (i = 0; i < N; i++)//外循环，遍历数组
27 {
28 if (arr[i] > num)//如果找到比插入的数更大的数
29 {
30 for (j = 9; j >= i; j--)//内循环，最后一位开始往后移动
31 {
32 arr[j + 1] = arr[j];
33 }
34
35 arr[i] = num;//插入
36
37 break;//记得break，不然往后一直是要插入的数6
38 }
39 }
40
41 printarr(arr, N);//打印数组
42
43 system("pause");
44 }
9 用选择法对10个整数由大到小排序
1 #include
2 #include
3
4 #define N 10
5
6 void selectionsort(int arr[], int n)//选择排序法
7 {
8 int i;
9 int j;
10 int max;//存储最大值下标
11
12 for (i = 0; i < n - 1; i++)//外循环
13 {
14 max = i;//假设当前为最大值
15
16 for (j = i + 1; j < n; j++)//内循环
17 {
18 if (arr[j] > arr[max])//如果找到更大值
19 {
20 max = j;//变更max
21 }
22 }
23
24 if (max != i)//如果max发生变更，交换
25 {
26 arr[max] ^= arr[i];
27 arr[i] ^= arr[max];
28 arr[max] ^= arr[i];
29 }
30 }
31 }
32
33 main()
34 {
35 time_t ts;
36 srand((unsigned int)time(&ts));
37 int arr[N] = { 0 };
38 int i;
39
40 for (i = 0; i < N; i++)
41 {
42 arr[i] = rand() % 1000;
43 printf("arr[%d]=%d\n", i, arr[i]);
44 }
45
46 selectionsort(arr, N);//选择排序法
47
48 printf("after\n");
49
50 for (i = 0; i < N; i++)
51 {
52 printf("arr[%d]=%d\n", i, arr[i]);
53 }
54
55 system("pause");
56 }
10 用筛选法求 2到 100之间的素数。方法如下：首先 2是素数，凡 2 的倍数都不是素数，于是把这些数从数表中筛去， 2以后没有被筛去的第一个数是 3， 然后把 3的倍数都从数表中筛去， 3以后没被筛去的第一个数是 5，然后把 5 的倍数都从数表中筛去。如此下去，直到遇到某数 K（≤ N），其后没有数可筛选为止， 这时保留下的未被筛去的数就是 2到 N的素数
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6
7 #define N 101
8
9 main()
10 {
11 int arr[N];//创建数组
12 int i;//数组下标
13 int j;//数组下标
14
15 for (i = 0; i < N; i++)
16 {
17 arr[i] = 1;//初始化数组，先默认都是素数，1是素数，0不是素数
18 }
19
20 arr[0] = arr[1] = 0;//0和1不是素数
21
22 for (i = 2; i < sqrt(N - 1); i++)//从2开始循环
23 {
24 while (!arr[i])//排除非素数，最后定向i为素数
25 {
26 i++;
27 }
28
29 for (j = i + i; j < N; j = j + i)//从i的2倍开始，每次递增倍数
30 {
31 arr[j] = 0;//i的倍数不是素数
32 }
33 }
34
35 for (i = 0; i < N; i++)
36 {
37 if (arr[i])//1是素数，0不是素数
38 {
39 printf("%d\n", i);
40 }
41 }
42
43 system("pause");
44 }
11 有17个人围成一圈（编号为0～16），从第 0号的人开始从 1报数， 凡报到 3的倍数的人离开圈子，然后再数下去，直到最后只剩下一个人为止。 问此人原来的位置是多少号？
可以使用数组解决，也可以使用循环链表解决。这里使用数组解决。
i = i % length + 1;//利用求余%运算，i在1~length之间循环
index = (index + 1) % m;//利用求余%运算，index在0~m-1之间循环
1 #include
2 #include
3
4 void main()
5 {
6 int length = 17;//总人数17个人
7 int m = 3;//报到 3的倍数的人离开圈子
8 int index = 0;//报数
9 int count = 0;//out的人数
10 int i = 0;//数组下标
11 int a[100] = { 0 };//初始化数组，0在场，1不在场
12
13 while (1)//死循环，直到out的人数等于总人数
14 {
15 i = i % length + 1;//利用求余%运算，i在1~length之间循环
16
17 if (a[i] == 0)//0在场，1不在场
18 {
19 index = (index + 1) % m;//利用求余%运算，index在0~m-1之间循环
20 if (index == 0)
21 {
22 count++;//out的人数增加
23 a[i] = 1;//0在场，1不在场
24 printf("这次out的人原来的位置是%d号\n", i);
25 }
26 }
27
28 if (length == count)//死循环，直到out的人数等于总人数
29 {
30 break;
31 }
32 }
33
34 system("pause");
35 }
12 打印所有不超过 n（ n<256）的其平方具有对称性的数（也称回文数）。
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 int getwei(int num)
7 {
8 if (num < 10)
9 {
10 return 1;
11 }
12 else
13 {
14 return getwei(num / 10) + 1;
15 }
16 }
17
18 int huiwen(int num)
19 {
20 int i;
21 int a[10] = { 0 };//初始化数组
22 int wei = getwei(num);//得到位数
23 int flag = 1;//1是回文数，0不是回文数
24
25 for (i = 0; i < wei; i++)//不断取出数字，保存到数组
26 {
27 a[i] = num % 10;//取出最后一位
28 num /= 10;//去掉最后一位，保留前面数字
29 }
30
31 for (i = 0; i < wei / 2; i++)//判断一半即可
32 {
33 if (a[i] != a[wei - 1 - i])//如果发现不是回文
34 {
35 flag = 0;//1是回文数，0不是回文数
36 break;
37 }
38 }
39
40 return flag;
41 }
42
43 void main()
44 {
45 int i;
46 int n = 256;
47
48 for (i = 0; i < n; i++)
49 {
50 if (huiwen(i*i))
51 {
52 printf("%d * %d = %d\n", i, i, i*i);
53 }
54 }
55
56 system("pause");
57 }
13 求N个数中的最大值，最大值出现的次数，然后求出次大值（次大值一定存在）。
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6
7 #define N 10
8
9 void searchMax1_Max2(int arr[], int num, int *pamx1, int *pamx2, int *pmax1_count)
10 {
11 int i;
12 *pamx1 = 0;//最大值，必须初始化为0
13 *pamx2 = 0;//次大值，必须初始化为0
14
15 for (i = 0; i < N; i++)
16 {
17 if (arr[i] > *pamx1)//找到比原来的最大值还大
18 {
19 *pmax1_count = 1;//恢复1
20 *pamx2 = *pamx1;//原来的最大值变成次大值
21 *pamx1 = arr[i];//保存新的最大值
22 }
23 else if (arr[i] == *pamx1)//找到重复的最大值
24 {
25 (*pmax1_count)++;//次数+1
26 }
27 else if (arr[i] > *pamx2 && arr[i] < *pamx1)//找到比原来的次大值还大，且比最大值还小
28 {
29 *pamx2 = arr[i];//保存新的次大值
30 }
31 else
32 {
33 continue;//继续循环
34 }
35 }
36 }
37
38 void main()
39 {
40 time_t ts;
41 srand((unsigned int)time(&ts));
42 int i;
43 int arr[N] = { 0 };//初始化数组
44 int max1 = 0;//保存最大值
45 int max2 = 0; //保存次大值
46 int max1_count = 1;//肯定存在最大值
47
48 for (i = 0; i < N; i++)
49 {
50 arr[i] = rand() % 10;
51 printf("arr[%d]=%d\n", i, arr[i]);
52 }
53
54 searchMax1_Max2(arr, N, &max1, &max2, &max1_count);//寻找最大值，次大值，和最大值出现的次数
55
56 printf("max1=%d,max2=%d,max1_count=%d", max1, max2, max1_count);
57
58 system("pause");
59 }
14 圆盘上有如下图所示的二十个数，请找出哪四个相邻数之和为最大，并指出它们的起始位置及最大和的值。
一维数组模拟圆，使用%来实现圆的循环，类似出圈游戏
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 #define N 20
7
8 void main()
9 {
10 int a[N] = { 20,1,8,4,13,6,10,15,2,17,3,19,7,16,8,11,14,9,12,5 };
11 int b[N] = { 0 };///相邻四个数之和，放入b[N]
12 int i;
13 int max = 0;//保存最大值
14 int index = 0;//保存最大值的下标
15
16 for (i = 0; i < N; i++)
17 {
18 b[i] = a[i] + a[(i + 1) % N] + a[(i + 2) % N] + a[(i + 3) % N];//一维数组模拟圆，使用%来实现圆的循环，类似出圈游戏
19 }
20
21 max = b[0];
22
23 for (i = 0; i < N; i++)
24 {
25 printf("b[%d]=%d\n", i, b[i]);
26 }
27
28 for (i = 1; i < N; i++)
29 {
30 if (b[i] > max)
31 {
32 index = i;
33 max = b[i];
34 }
35 }
36
37 printf("index=%d,max=%d\n", index + 1, max);
38
39 system("pause");
40 }
15 将一个一维数组中的偶数依次交换。例如有8个元素， 若其中第1、4、5三元素是偶数时应按下图交换。
1 #include
2 #include
3 #define N 8
4
5 int *getFirst(int arr[], int n)//返回第一个偶数的地址
6 {
7 int *pFirst = NULL;//保存地址
8 for (int *p = arr; p < arr + n; p++)//从前到后
9 {
10 if (!(*p % 2))
11 {
12 pFirst = p;
13 break;
14 }
15 }
16 return pFirst;
17 }
18
19 int *getLast(int arr[], int n)//返回最后一个偶数的地址
20 {
21 int *pLast = NULL;//保存地址
22 for (int *p = arr + n - 1; p >= arr; p--)//从后到前
23 {
24 if (!(*p % 2))
25 {
26 pLast = p;
27 break;
28 }
29 }
30 return pLast;
31 }
32
33 void main()
34 {
35 int arr[N] = { 2,3,1,6,8,7,9,5 };//初始化数组
36 int i;
37
38 for (i = 0; i < N; i++)
39 {
40 printf("%5d", arr[i]);
41 }
42
43 int *pLast = getLast(arr, N);//返回最后一个偶数的地址
44 int lastValue = *pLast;//保存最后一个偶数的值
45
46 int *pFirst = getFirst(arr, N);//返回第一个偶数的地址
47
48 for (int *p = pLast - 1; p >= pFirst; p--)//从最后一个偶数的前一个地址开始往前循环，到第一个偶数为止
49 {
50 if (!(*p % 2))
51 {
52 *pLast = *p;//往后赋值
53 pLast = p;//将当前偶数赋给标识变量pLast
54 }
55 }
56
57 *pFirst = lastValue;//第一个偶数的地址，需要赋上当初最后一个偶数的值
58
59 printf("\n调整以后\n");
60 for (i = 0; i < N; i++)
61 {
62 printf("%5d", arr[i]);
63 }
64
65 system("pause");
66 }
16 有n个整数，编程序将前面的各个数依次向后移动k个位置，最后k个数移到最前边的k个位置（见下图，其中n=8，k=3）。
1 2 3 4 5 6 7 8
6 7 8 1 2 3 4 5
思考: 程序中不许引入其它数组。
第一次，8 7 6 4 5 3 2 1
第二次，6 7 8 4 5 3 2 1
第三次，6 7 8 1 4 5 3 2
第四次，6 7 8 1 2 4 5 3
第五次，6 7 8 1 2 3 4 5
1 #include
2 #include
3
4 #define N 8
5
6 void print(int arr[], int n)
7 {
8 int i;
9
10 for (i = 0; i < n; i++)
11 {
12 printf("%5d", arr[i]);
13 }
14 printf("\n");
15 }
16
17 void main()
18 {
19 int arr[N] = { 1,2,3,4,5,6,7,8 };
20 int k = 3;
21 int i;
22 int temp = 0;
23 int j;
24
25 print(arr, N);
26
27 for (i = 0; i < 3; i++)//第一步，对调前k项和后k项
28 {
29 temp = arr[i];
30 arr[i] = arr[N - 1 - i];
31 arr[N - 1 - i] = temp;
32 }
33
34 print(arr, N);//8 7 6 4 5 3 2 1
35
36 for (i = 0; i < k / 2; i++)//第二步，前k项逆序
37 {
38 temp = arr[i];
39 arr[i] = arr[k - 1 - i];
40 arr[k - 1 - i] = temp;
41 }
42
43 print(arr, N);//6 7 8 4 5 3 2 1
44
45 for (i = k; i < 2 * k; i++)
46 {
47 temp = arr[N - 1];//存储最后一个元素
48
49 for (j = N - 2; j > i - 1; j--)//后N - k - 1个元素向后移动
50 {
51 arr[j + 1] = arr[j];
52 }
53 arr[i] = temp;//原来最后一个元素向前
54
55 print(arr, N);
56 }
57 }
17 自然数N一般写成如下形式:
N=dk dk-1 d1 （d1～dk 均是十进制数字）
如果di+1 >di (i=k-1,k-2,...,1)，则称N是严格降序数；如果di+1
1 #include
2 #include
3 #include <string.h>
4
5 #define N 10
6
7 int arr[N] = { 0 };//初始化数组0
8
9 int isequal(int n)//等序返回1
10 {
11 if (n == 1)
12 {
13 return arr[n - 1] == arr[n];
14 }
15 else
16 {
17 return (arr[n - 1] == arr[n]) && isequal(n - 1);
18 }
19 }
20
21 int isminus(int n)//降序返回1
22 {
23 if (n == 1)
24 {
25 return arr[n - 1] > arr[n];
26 }
27 else
28 {
29 return (arr[n - 1] > arr[n]) && isminus(n - 1);
30 }
31 }
32
33 int isadd(int n)//升序返回1
34 {
35 if (n == 1)
36 {
37 return arr[n - 1] < arr[n];
38 }
39 else
40 {
41 return (arr[n - 1] < arr[n]) && isadd(n - 1);
42 }
43 }
44
45 int getwei(int n)//返回整数位数
46 {
47 if (n < 10)
48 {
49 return 1;
50 }
51 else
52 {
53 return getwei(n / 10) + 1;
54 }
55 }
56
57 void arrSet(int arr[], int num)//把整数各位存放到数组
58 {
59 memset(arr, -1, sizeof(arr));//初始化数组-1
60 int i;
61 int wei = getwei(num);//返回整数位数
62
63 for (i = wei - 1; i >= 0; i--)//把整数各元素放入数组
64 {
65 arr[i] = num % 10 + 48;
66 num /= 10;
67 }
68 }
69
70 void arrJudge(int arr[], int num)//判断整数
71 {
72 int wei = getwei(num);//返回整数位数
73
74 if (num <= 9)
75 {
76 printf("从键盘上输入一个大于9的整数\n");
77 }
78 else if (isadd(wei - 1))
79 {
80 printf("严格升序数\n");
81 }
82 else if (isminus(wei - 1))
83 {
84 printf("严格降序数\n");
85 }
86 else if (isequal(wei - 1))
87 {
88 printf("等序数\n");
89 }
90 else
91 {
92 printf("无序数\n");
93 }
94 }
95
96 void main()
97 {
98 int num = 1234;
99
100 arrSet(arr, num);//把整数各位存放到数组
101
102 arrJudge(arr, num);//判断整数
103
104 system("pause");
105 }
18 已知A是有30个元素的整型数组，编写一个对A[I1]到A[I2]（I1≤I2）之间的元素排序的函数（从大到小排序）。请调用上述函数先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出。再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出。
要求：1) 输入输出均由主函数实现。
2) 输出时每10个元素占1行。
1 #include
2 #include
3 #include
4
5 #define N 30
6
7 void sortPart(int arr[], int n, int i1, int i2)//仅对arr[i1]->arr[i2]之间的元素进行排序，冒泡排序
8 {
9 int i;
10 int j;
11 int temp;
12
13 for (i = n - i2 - 1; i < n - 1; i++)//i = n - i2 - 1
14 {
15 for (j = i1; j < n - 1 - i; j++)//j = i1
16 {
17 if (arr[j] > arr[j + 1])
18 {
19 temp = arr[j];
20 arr[j] = arr[j + 1];
21 arr[j + 1] = temp;
22 }
23 }
24 }
25 }
26
27 void main()
28 {
29 time_t ts;
30 srand((unsigned int)time(&ts));
31 int A[N] = { 0 };//数组
32 int i = 0;//数组下标
33 int i1 = 0;//数组下标
34 int i2 = 0;//数组下标
35
36 for (i = 0; i < N; i++)//打印
37 {
38 A[i] = rand() % 100;//初始化数组
39
40 printf("%5d", A[i]);
41
42 if (!((i + 1) % 10))//输出时每10个元素占1行
43 {
44 printf("\n");
45 }
46 }
47
48 printf("先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出\n");
49
50 i1 = 5;//修改下标
51 i2 = 20;//修改下标
52
53 sortPart(A, N, i1, i2);//仅对i1至i2至今的元素进行排序，冒泡
54
55 for (i = 0; i < N; i++)//打印
56 {
57 printf("%5d", A[i]);
58
59 if (!((i + 1) % 10))//输出时每10个元素占1行
60 {
61 printf("\n");
62 }
63 }
64
65 printf("再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出\n");
66
67 i1 = 15;//修改下标
68 i2 = 29;//修改下标
69
70 sortPart(A, N, i1, i2);//仅对arr[i1]->arr[i2]之间的元素进行排序，冒泡排序
71
72 for (i = 0; i < N; i++)//打印
73 {
74 printf("%5d", A[i]);
75
76 if (!((i + 1) % 10))//输出时每10个元素占1行
77 {
78 printf("\n");
79 }
80 }
81 }
19 编写求最大平台问题的程序。
有n个整数a1,a2, ... an, 若满足a1≤a2≤ ... ≤ an ，则认为在这n个数中有最大平台。在这种情况下，若n个数互不相同，则最大平台值为1，若在n个数中最多有连续m个整数的值相等，则最大平台值为m。
例如: n=10时
1,2,3,4,5,6,6,7,4,5 无最大平台
1,1,2,2,2,2,2,2,2,2 最大平台值为8
1,1,2,2,2,3,3,4,4,5 最大平台值为3
0,1,2,3,4,5,6,7,8,9 最大平台值为1
1 #include
2 #define N 10
3
4 int platformExist(int arr[], int n);//判断是否有最大平台
5 int platformOnly(int arr[], int n);//判断最大平台值是否为1
6 int platformBiggest(int arr[], int n);//获取最大平台值
7
8 void main()
9 {
10 int arr[N] = { 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 };
11
12 if (platformExist(arr, N))//判断是否有最大平台
13 {
14 if (platformOnly(arr, N))//判断最大平台值是否为1
15 {
16 printf("最大平台值为1\n");
17 }
18 else
19 {
20 printf("最大平台值为%d\n", platformBiggest(arr, N));//获取最大平台值
21 }
22 }
23 else
24 {
25 printf("无最大平台\n");
26 }
27 }
28
29 int platformExist(int arr[], int n)//判断是否有最大平台
30 {
31 int i = 0;//数组下标
32 int flag = 1;//默认有最大平台
33
34 for (i = 0; i < N - 1; i++)
35 {
36 if (arr[i] > arr[i + 1])
37 {
38 flag = 0;
39 break;
40 }
41 }
42
43 return flag;
44 }
45
46 int platformOnly(int arr[], int n)//判断最大平台值是否为1
47 {
48 int i = 0;//数组下标
49 int flag = 1;//默认最大平台值为1
50
51 for (i = 0; i < N - 1; i++)
52 {
53 if (arr[i] == arr[i + 1])
54 {
55 flag = 0;
56 break;
57 }
58 }
59
60 return flag;
61 }
62
63 int platformBiggest(int arr[], int n)//获取最大平台值
64 {
65 int i = 0;//数组下标
66 int j = 0;//数组下标
67 int max = 0;//保存最大平台值
68 int s = 0;//临时变量
69
70 for (i = 0; i < n; i++)
71 {
72 s = 0;
73
74 for (j = i; j < n; j++)
75 {
76 if (arr[i] == arr[j])
77 {
78 s++;
79 }
80
81 if (s > max)
82 {
83 max = s;
84 }
85 }
86 }
87
88 return max;
89 }
20 某桔农家共有2520只桔子, 父亲要将它们分给六个儿子，其分法如下：父亲先将2520只桔子分给六个儿子, 然后说：“老大，把你分到的桔子的八分之一给老二；老二拿到以后，连同原来的桔子分出七分之一给老三；老三拿到以后，连同原来的桔子分出六分之一给老四；老四拿到以后，连同原来的桔子分出五分之一给老五；老五拿到以后，连同原来的桔子分出四分之一给老六；老六拿到以后，连同原来的桔子分出三分之一给老大”。这样分完之后，六个儿子手里的桔子正好一样多。问六个儿子原先分到的桔子各是多少只？
1 #include
2 #define N 6
3
4 void main()
5 {
6 const int total = 2520;//共有2520只桔子
7 int arr[N] = { 0 };//初始化数组
8 int i;//数组下标
9
10 for (i = 0; i < N; i++)//最终结果每人一样
11 {
12 arr[i] = total / N;
13 }
14
15 arr[0] = arr[0] - arr[5] / 2;//老大接受老六的馈赠后便等于2520/6,故初始化老大的送完老二后的值
16
17 for (i = 5; i > 0; i--)
18 {
19 arr[i] = arr[i] + arr[i] / (7 - i) - arr[i] / (8 - i);
20 }
21
22 arr[0] = arr[0] + arr[0] / 7;///加上开始送给老二的桔子
23
24 for (i = 0; i < N; i++)//打印
25 {
26 printf("第%d个人原先分到的桔子是%d只\n", i + 1, arr[i]);
27 }
28 }
21 间隔元素排序。用随机函数产生25个[25,75]之间的整数， 把它送到一维数组M中。要求对M[I],M[I+J],M[I+2*J],…这些元素按从小到大的顺序排序。J的值由键盘输入，I从1到J变化。实际上是以J为间隔排了J个对列，每个对列中从小到大排序。
1 #include
2 #include
3 #include
4 #define N 25
5
6 void print(int arr[], int n);//打印数组
7 void sortJ(int arr[], int n, int j);//间隔元素排序
8
9 void main()
10 {
11 time_t ts;
12 srand((unsigned int)time(&ts));
13 int arr[N] = { 0 };//初始化数组
14 int i;//数组下标
15 int j = 11;//间隔
16
17 for (i = 0; i < N; i++)
18 {
19 arr[i] = rand() % 100;//赋值
20 }
21
22 print(arr, N);//打印数组
23
24 printf("间隔元素排序\n");
25
26 sortJ(arr, N, j);//间隔元素排序
27
28 print(arr, N);//打印数组
29 }
30
31 void print(int arr[], int n)//打印数组
32 {
33 int i;//数组下标
34
35 for (i = 0; i < n; i++)
36 {
37 printf("%5d", arr[i]);
38 if ((i + 1) % 5 == 0)
39 {
40 printf("\n");
41 }
42 }
43 }
44
45 void sortJ(int arr[], int n, int j)//间隔元素排序
46 {
47 int i = 0;//数组下标
48 int p = 0;//数组下标
49 int q = 0;//数组下标
50 int temp = 0;//临时
51
52 for (i = 0; i < n; i += j)//外循环，间隔
53 {
54 for (p = i; p < i + j - 1 && p < n; p++)//内循环，排序，注意不要越界
55 {
56 for (q = i; q < i + j - 1 && q < n - 1; q++)//内循环，排序，注意不要越界
57 {
58 if (arr[q] > arr[q + 1])
59 {
60 temp = arr[q];
61 arr[q] = arr[q + 1];
62 arr[q + 1] = temp;
63 }
64 }
65 }
66 }
67 }
22 求阶乘N!。
设输入的N最大可使N!达到100位，要求打印出全部有效数字。方法如下：用数组M[100]代表一个100位的数。M[1]代表最高位，M[100] 代表最低位。先对M[100]置1，其余各元素置零，然后从1到N进行累乘。同通常作乘法一样，数组M与I（1≤I≤N）相乘时，从低位数乘起，乘积大于9时进到上一位去，然后将结果打印（从头一个不等于零的位开始）。
1 #include
2 #include
3
4 void main()
5 {
6 int M[100] = { 0 };//用数组M[100]代表一个100位的数
7 M[99] = 1;//先对M[99]置1
8 int i = 1;//1至100阶乘N!
9 int j = 99;//数组下标
10 int JW = 0;//进位
11 int num = 0;//临时乘积
12
13 for (i = 1; i < 100; i++)
14 {
15 JW = 0;//进位置为0
16
17 for (j = 99; j >= 0; j--)
18 {
19 int num = M[j] * i + JW;
20
21 if (num > 9)//如果大于9，需要进位
22 {
23 M[j] = num % 10;//保存个位数
24 JW = num / 10;//进位
25 }
26 else
27 {
28 M[j] = M[j] * i + JW;
29 JW = 0;//进位置为0
30 }
31 }
32 }
33
34 i = 0;
35 while (M[i] == 0)//从头一个不等于零的位开始
36 {
37 i++;
38 }
39
40 while (i < 100)//打印结果
41 {
42 printf("%d ", M[i]);
43 i++;
44 }
45 }
23 编写“N个人放鞭炮问题的程序”。
N个人同时刻开始放鞭炮， 第一个人每隔T1秒放一次，第二个人每隔T2秒放一次，...第N个人每隔Tn秒放一次。每个人各放M个鞭炮。问总共能听到多少次鞭炮声。
1 #include
2 #include
3
4 #define N 5//N个人
5 #define M 10//每个人各放M个鞭炮
6
7 void main()
8 {
9 int arr[N*M] = { 0 };//数组的元素个数是N*M，1代表听到鞭炮声，0代表没有听到鞭炮声
10 int i = 0;//临时变量，用于循环
11 int j = 0;//临时变量，用于循环
12 int k = 0;//临时变量，用于循环
13 int count = 0;//计数器
14 int cnt = 0;//计数器
15
16 for (i = 0; i < N; i++)//外循环，N个人
17 {
18 count = 0;//计数器
19 j = 0;//每次从0开始听到鞭炮声
20 k++;//每隔k秒放一次
21
22 while (count < M)//内循环，每个人各放M个鞭炮
23 {
24 arr[j] = 1;//1代表听到鞭炮声，0代表没有听到鞭炮声
25 j += k;//秒数+k
26 count++;//计数器
27 }
28 }
29
30 for (i = 0; i < N*M; i++)//循环，查找有听到鞭炮声的秒数
31 {
32 if (arr[i])
33 {
34 cnt++;//计数器
35 printf("%d ", i);//打印有听到鞭炮声的秒数
36 }
37 }
38
39 printf("总共能听到%d次鞭炮声\n", cnt);
40 }
24 十个数字组成完全平方数。
把0、1、2、3、4、5、6、7、8、9十个数字分别组成一个一位数，一个二位数，一个三位数和一个四位数，使它们都是完全平方数（其平方根是整数），共有几种方法? 每种方法的结果是什么? （每个数字只允许用一次）。下边就是一种填法：
１ （ １ ）
３６ （ ６ ）
７８４ （ ２８ ）
９０２５ （ ９５ ）
1 #include
2 #include
3 #include <string.h>
4 #include
5
6 bool fillarr(int *arr, int num)
7 {
8 int temp = 0;//临时变量
9
10 if (num)//如果不是0
11 {
12 while (num)
13 {
14 temp = num % 10;//取出个位数
15 if (!arr[temp])//如果该下标没有被占用
16 {
17 arr[temp] = 1;//占用
18 }
19 else
20 {
21 return false;
22 }
23 num /= 10;//去掉个位数
24 }
25 }
26 else//如果是0
27 {
28 if (!arr[num])//如果该下标没有被占用
29 {
30 arr[num] = 1;//占用
31 }
32 else
33 {
34 return false;
35 }
36 }
37
38 return true;
39 }
40
41 void main()
42 {
43 int count = 0;//计数器
44 int arr[10] = { 0 };//初始化数组，10个数字，10个元素，下标一一对应，1代表已经占用，0代表没有占用
45 int i = 0;
46 int j = 0;
47 int k = 0;
48 int l = 0;
49
50 for (i = 0; i < 4; i++)//一位数，临界值0*0==0，3*3==9
51 {
52 for (j = 4; j < 10; j++)//两位数，临界值4*4==16，9*9==81
53 {
54 for (k = 10; k < 32; k++)//三位数，临界值10*10==100，31*31==961
55 {
56 for (l = 32; l < 100; l++)//四位数，临界值32*32==1024，99*99==9801
57 {
58 memset(arr, 0, sizeof(arr));//清零
59 if (fillarr(arr, i*i) && fillarr(arr, j*j) && fillarr(arr, k*k) && fillarr(arr, l*l))//判断
60 {
61 count++;//计数器
62 printf("%d(%d) %d(%d) %d(%d) %d(%d)\n", i*i, i, j*j, j, k*k, k, l*l, l);
63 }
64 }
65 }
66 }
67 }
68
69 printf("共有%d种方法\n", count);
70 }
------------------------------二维数组
9 对一个二维数组进行转置
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 main()
7 {
8 int a[3][4] = { 1,2,3,4,5,6,7,8,0,1,2,3 };
9 int i, j;
10 int b[4][3];//存储转置后的数据
11
12 for (i = 0;i < 3;i++)
13 {
14 for (j = 0;j < 4;j++)
15 {
16 printf("%-5d", a[i][j]);
17 }
18 printf("\n");
19 }
20
21 printf("以下是转置\n");
22
23 for (i = 0;i < 4;i++)
24 {
25 for (j = 0;j < 3;j++)
26 {
27 b[i][j] = a[j][i];
28 printf("%-5d", b[i][j]);
29 }
30 printf("\n");
31 }
32
33 system("pause");
34 }
10 打印杨辉三角形，包括直角三角形和等腰三角形
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 #define N 10
7
8 main()
9 {
10 int a[N][N] = { 0 };
11 int i, j;
12
13 for (i = 0;i < N;i++)
14 {
15 for (j = 0;j <= i;j++)
16 {
17 if (j == 0 || i == j)
18 {
19 a[i][j] = 1;
20 }
21 else
22 {
23 a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
24 }
25 printf("%5d", a[i][j]);
26 }
27 printf("\n");
28 }
29
30 printf("输出等腰三角形\n");
31
32
33 for (i = 0;i < N;i++)
34 {
35 printf("%*d", 30 - i * 2, a[i][0]);//打印第一列，30是随意值，30 - i * 2，2必须是下下行的一半
36 for (j = 1;j <= i;j++)
37 {
38 printf("%4d", a[i][j]);//%4d，4个字符的宽度，必须为上上行的2倍
39 }
40 printf("\n");
41 }
42
43 system("pause");
44 }
11 有一个班，3个学生，各学4门课，计算总平均分以及第n个学生的成绩。查找有一门以上课程不及格的学生，输出该学生的所有成绩
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 void avg(int(*p)[4], int n)//用指向数组的指针存储二维数组名，传递多少个元素（一维数组）
7 {
8 int i, j;
9 double res = 0;
10
11 for (i = 0;i < 3;i++)
12 {
13 for (j = 0;j < 4;j++)
14 {
15 res += p[i][j];
16 }
17 }
18
19 res /= 12;
20 printf("%f\n", res);
21 }
22
23 void show(int(*p)[4], int num)
24 {
25 int i;
26
27 for (i = 0;i < 4;i++)
28 {
29 printf("%6d", p[num][i]);//打印num行的所有数据
30 }
31 }
32
33 void fail(int(*p)[4])
34 {
35 int i, j;
36 int flag = 1;//假设及格=1
37
38 for (i = 0;i < 3;i++)
39 {
40 flag = 1;
41 for (j = 0;j < 4;j++)
42 {
43 if (p[i][j] < 60)
44 {
45 flag = 0;//检测到不及格就退出循环
46 break;
47 }
48 }
49 if (flag == 0)//检测到不及格就全部打印
50 {
51 for (j = 0;j < 4;j++)
52 {
53 printf("%5d", p[i][j]);
54 }
55 printf("\n");
56 }
57 }
58 }
59
60 main()
61 {
62 int a[3][4] = { {45,68,97,68},{89,67,65,99},{100,89,98,86} };
63 int num;
64 avg(a, 3);
65
66 //scanf("%d", &num);
67 //show(a, num);
68
69 fail(a);
70
71 system("pause");
72 }
12 打印如下形式的杨辉三角形
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
输出前10行，从 0行开始，分别用一维数组和二维数组实现
二维数组
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 #define N 10
7
8 void main()
9 {
10 int arr[N][N] = { 0 };//初始化数组
11 int i;
12 int j;
13
14 for (i = 0; i < N; i++)
15 {
16 for (j = 0; j <= i; j++)//对角线左下
17 {
18 if (j == 0 || i == j)
19 {
20 arr[i][j] = 1;//如果是每行第0列或者是对角线上，为1
21 }
22 else
23 {
24 arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];//其他为上一行上一列arr[i - 1][j - 1]和上一行本列arr[i - 1][j]之和
25 }
26 printf("%6d", arr[i][j]);
27 }
28 printf("\n");
29 }
30
31 system("pause");
32 }
13 把一个二维实型数组a按照第0列的元素进行排序（由小到大排序，用起泡法）。例如：如果a[i][0]大于a[i+1][0]，则i行与i+1行中所有元素都要进行对换
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6
7 #define N 10
8
9 void zhizhen_myswap(int(*arr)[N], int n, int num1, int num2)//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用指针
10 {
11 int i;
12 int temp;
13
14 for (i = 0; i < n; i++)
15 {
16 temp = *(*(arr + num1) + i);
17 *(*(arr + num1) + i) = *(*(arr + num2) + i);
18 *(*(arr + num2) + i) = temp;
19 }
20 }
21
22 void xiabiao_myswap(int arr[][N], int n, int num1, int num2)//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用数组下标
23 {
24 int i;
25
26 for (i = 0; i < n; i++)
27 {
28 arr[num1][i] ^= arr[num2][i];
29 arr[num2][i] ^= arr[num1][i];
30 arr[num1][i] ^= arr[num2][i];
31 }
32 }
33
34 main()
35 {
36 int i;
37 int j;
38 int arr[N][N] = { 0 };//初始化二维数组
39 time_t ts;
40 srand((unsigned int)time(&ts));
41
42 for (i = 0; i < N; i++)
43 {
44 for (j = 0; j < N; j++)
45 {
46 arr[i][j] = rand() % 100;
47 printf("%6d", arr[i][j]);
48 }
49 printf("\n");
50 }
51
52 for (i = 0; i < N - 1; i++)
53 {
54 for (j = 0; j < N - 1 - i; j++)
55 {
56 if (arr[j][0]>arr[j + 1][0])
57 {
58 //xiabiao_myswap(arr, 10, j, j + 1);//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用数组下标
59 zhizhen_myswap(arr, 10, j, j + 1);//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用指针
60 }
61 }
62 }
63
64 printf("after\n");
65
66 for (i = 0; i < N; i++)
67 {
68 for (j = 0; j < N; j++)
69 {
70 printf("%6d", arr[i][j]);
71 }
72 printf("\n");
73 }
74
75
76 system("pause");
77 }
14 编程产生如下形式的方阵。
1 2 2 2 2 2 1
3 1 2 2 2 1 4
3 3 1 2 1 4 4
3 3 3 1 4 4 4
3 3 1 5 1 4 4
3 1 5 5 5 1 4
1 5 5 5 5 5 1
要求：不允许使用键盘输入语句和静态赋值语句，尽量少用循环。
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 #define N 7
7
8 main()
9 {
10 int a[N][N] = { 0 };//初始化数组
11 int i;
12 int j;
13
14 for (i = 0; i < N; i++)
15 {
16 for (j = 0; j < N; j++)
17 {
18 if (i == j || i + j == 6)//两条对角线为1
19 {
20 a[i][j] = 1;
21 }
22 else if (i < j && i + j < 6)//上边为2
23 {
24 a[i][j] = 2;
25 }
26 else if (i > j && i + j < 6)//左边为3
27 {
28 a[i][j] = 3;
29 }
30 else if (i < j && i + j > 6)//右边为4
31 {
32 a[i][j] = 4;
33 }
34 else//其他，即是下边为5
35 {
36 a[i][j] = 5;
37 }
38 printf("%2d", a[i][j]);
39 }
40 printf("\n");
41 }
42
43 system("pause");
44 }
15 找出 M×N 数组中所有不相邻元素，并求出它们的和（相邻的数：前一个是偶数，后一个是素数）。
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5 #include
6 #include
7
8 #define M 10
9 #define N 10
10
11 int jiou(int num)//1是奇数，0是偶数
12 {
13 return num % 2;
14 }
15
16 int isprime(int num)//1是素数，0不是素数
17 {
18 int flag = 1;
19 int i;
20
21 if (num < 2)
22 {
23 flag = 0;
24 }
25 else if (num == 2)
26 {
27 flag = 1;
28 }
29 else
30 {
31 for (i = 2; i <= sqrt(num); i++)
32 {
33 if (!(num%i))
34 {
35 flag = 0;
36 break;
37 }
38 }
39 }
40
41 return flag;
42 }
43
44 void main()
45 {
46 time_t ts;
47 srand((unsigned int)time(&ts));
48 int arr[M][N] = { 0 };//初始化数组
49 int i;//数组下标
50 int j;//数组下标
51 int flag = 0;//1是符合，0不符合
52 int sum = 0;//和
53
54 for (i = 0; i < M; i++)
55 {
56 for (j = 0; j < N; j++)
57 {
58 arr[i][j] = rand() % 100;//随机赋值
59 printf("%5d", arr[i][j]);//打印
60 }
61 printf("\n");
62 }
63
64 int *p = &arr[0][0];//指针，指向第一个元素的地址
65
66 if (!jiou(*(p)) && isprime(*(p + 1)))//判断第一个元素，如果第一个元素是偶数，第二个元素是素数
67 {
68 sum += *(p);
69 printf("0,%d\n", *(p));
70 }
71
72 for (i = 1; i < M*N - 1; i++)//从第二个元素开始循环，直到倒数第二个元素
73 {
74 flag = 0;//默认不符合
75
76 if (!jiou(*(p + i - 1)) && isprime(*(p + i)))//如果前一个是偶数，它本是素数
77 {
78 flag = 1;
79 }
80 else if (!jiou(*(p + i)) && isprime(*(p + i + 1)))//如果它本是偶数，后一个是素数
81 {
82 flag = 1;
83 }
84
85 if (flag == 1)
86 {
87 sum += *(p + i);
88 printf("%d,%d\n", i, *(p + i));
89 }
90 }
91
92 if (!jiou(*(p + M*N - 2)) && isprime(*(p + M*N - 1)))//判断最后一个元素，如果倒数第二个元素是偶数，最后一个元素是素数
93 {
94 sum += *(p + M*N - 1);
95 printf("%d,%d\n", i, *(p + M*N - 1));
96 }
97
98 printf("sum=%d\n", sum);
99
100 system("pause");
101 }
16 打印魔方阵。所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。例如：三阶魔方阵为
8 1 6
3 5 7
4 9 2
要求打印由 1到的自然数构成的魔方阵。
提示：魔方阵中各数的排列规律如下：
⑴ 将“1”放在第一行中间一列；
⑵ 从“2”开始直到n×n为止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1；
⑶ 如果上一个数的行数为1，则下一个数的行数为 n（指最下一行）；
⑷ 当一个数的列数为 n，下一个数的列数应为1，行数减1；
⑸ 如果按上面规则确定的位置已有数，或上一个数是第 1行第 n列时， 则把下一个数放在上一个数的下面。
1 #define _CRT_SECURE_NO_WARNINGS
2
3 #include
4 #include
5
6 #define N 3//N可以为任何奇数，因为偶数矩阵没有对角线，故不符合题意
7
8 void main()
9 {
10 int a[N][N] = { 0 };//初始化数组
11 int num = 1;//⑴ 将“1”放在第一行中间一列；
12
13 int i = 0;//⑴ 将“1”放在第一行中间一列；
14 int j = N / 2;//⑴ 将“1”放在第一行中间一列；
15
16 int ci = 0;
17 int cj = 0;
18
19 for (num = 1; num <= N*N; num++)
20 {
21 a[i][j] = num;//保存数字
22 ci = i;//保存上一个数字的位置
23 cj = j;//保存上一个数字的位置
24
25 i = ci - 1;//⑵ 从“2”开始直到n×n为止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1；
26 j = cj + 1;
27
28 if (ci == 0)//⑶ 如果上一个数的行数为1，则下一个数的行数为 n（指最下一行）；
29 {
30 i = N - 1;
31 }
32
33 if (cj == N - 1)//⑷ 当一个数的列数为 n，下一个数的列数应为1，行数减1；
34 {
35 j = 0;
36 i = ci - 1;
37 }
38
39 if (a[i][j] != 0 || ci == 0 && cj == N - 1)//⑸ 如果按上面规则确定的位置已有数，或上一个数是第 1行第 n列时， 则把下一个数放在上一个数的下面。
40 {
41 i = ci + 1;
42 j = cj;
43 }
44 }
45
46 for (i = 0; i < N; i++)//打印数组
47 {
48 for (j = 0; j < N; j++)
49 {
50 printf("%5d", a[i][j]);
51 }
52 printf("\n");
53 }
54
55 system("pause");
56 }
17 找规律，编程序打印6×6的矩阵:
1 2 3 5 8 13
1 4 9 17 30 51
1 6 19 45 92 173
. . .
1 #define _CRT_SECURE_NO_WARNINGS
2 #include
3
4 #define N 6
5
6 void main()
7 {
8 int arr[N][N] = { 0 };
9 int i;
10 int j;
11
12 for (i = 0; i < N; i++)
13 {
14 for (j = 0; j < N; j++)
15 {
16 if (j == 0)//第0列是1
17 {
18 arr[i][j] = 1;
19 printf("%5d", arr[i][j]);
20 }
21 else if (i == 0)//第0行
22 {
23 if (j == 1)//第0行第1列是2
24 {
25 arr[i][j] = 2;
26 }
27 else//第0行是从第2列开始前2列之和
28 {
29 arr[i][j] = arr[i][j - 1] + arr[i][j - 2];
30 }
31 printf("%5d", arr[i][j]);
32 }
33 else
34 {
35 arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j] + arr[i][j - 1];//其他是左上方，上方，左方之和
36 printf("%5d", arr[i][j]);
37 }
38 }
39 printf("\n");
40 }
41 }
18 已知M1是3×5的矩阵, M2是5×2的矩阵, 编程序求出M1与M2之积。
1 #include
2 #include
3 #include
4
5 void main()
6 {
7 time_t ts;
8 srand((unsigned int)time(&ts));
9 int M1[3][5] = { 0 };
10 int M2[5][2] = { 0 };
11 int M3[3][2] = { 0 };
12 int i;
13 int j;
14 int k;
15 int sum = 0;
16
17 for (i = 0; i < 3; i++)//数组M1赋值
18 {
19 for (j = 0; j < 5; j++)
20 {
21 M1[i][j] = rand() % 2;
22 printf("%5d", M1[i][j]);
23 }
24 printf("\n");
25 }
26
27 printf("\n\n");
28
29 for (i = 0; i < 5; i++)//数组M2赋值
30 {
31 for (j = 0; j < 2; j++)
32 {
33 M2[i][j] = rand() % 2;
34 printf("%5d", M2[i][j]);
35 }
36 printf("\n");
37 }
38
39 printf("\n\n");
40
41 for (i = 0; i < 3; i++)//计算数组M3
42 {
43 for (j = 0; j < 2; j++)
44 {
45 sum = 0;
46 for (k = 0; k < 5; k++)
47 {
48 sum += M1[i][k] * M2[k][j];
49 }
50 M3[i][j] = sum;
51 }
52 }
53
54 for (i = 0; i < 3; i++)//打印
55 {
56 for (j = 0; j < 2; j++)
57 {
58 printf("%5d", M3[i][j]);
59 }
60 printf("\n");
61 }
62
63 system("pause");
64 }
19 找规律填写N×N方阵。如N=8时, 其方阵为:
1 1 1 1 1 1 1 1
1 2 2 2 2 2 2 1
1 2 3 3 3 3 2 1
1 2 3 4 4 3 2 1
1 2 3 4 4 3 2 1
1 2 3 3 3 3 2 1
1 2 2 2 2 2 2 1
1 1 1 1 1 1 1 1
1 #include
2 #include
3
4 #define N 8
5
6 void main()
7 {
8 int a[N][N] = { 0 };
9
10 int i;
11 int j;
12 int k;
13 int u;
14 int v;
15 int data = 1;
16
17 for (i = 0, j = 0, k = 0; k < (N + 1) / 2; k++, data++)
18 {
19 while (i < N - k)//左列赋值
20 {
21 a[i][j] = data;
22 i = i + 1;
23 }
24 i--;
25 j++;
26
27 while (j < N - k)//下行赋值
28 {
29 a[i][j] = data;
30 j = j + 1;
31 }
32 j--;
33 i--;
34
35 while (i > k - 1)//右列赋值
36 {
37 a[i][j] = data;
38 i = i - 1;
39 }
40 i++;
41 j--;
42
43 while (j > k)//上行赋值
44 {
45 a[i][j] = data;
46 j = j - 1;
47 }
48 i++;
49 j++;
50 }
51
52 for (u = 0; u < N; u++)//打印
53 {
54
55 for (v = 0; v < N; v++)
56 {
57 printf("%d\t", a[u][v]);
58
59 }
60 printf("\n");
61 }
62
63 system("pause");
64 }
20 求N阶方阵（即N×N数组）中各条反斜线上的元素之和。如4×4数组共有7条反斜线：
注：求和时，请按斜线编号顺序显示求出的和。
1 #include
2 #include
3 #include
4
5 #define N 4
6
7 void main()
8 {
9 time_t ts;
10 srand((unsigned int)time(&ts));
11 int arr[N][N] = { 0 };//初始化数组
12 int arrSum[2 * N - 1] = { 0 };//初始化数组，存储各条反斜线上的元素之和
13 int i;//数组下标
14 int j;;//数组下标
15 int sum = 0;//临时变量，存储反斜线上的元素之和
16 int m;//数组下标
17 int n;//数组下标
18 int count = 0;//存储各条反斜线上的编号
19
20 for (int i = 0; i < N; i++)//随机赋值
21 {
22 for (int j = 0; j < N; j++)
23 {
24 arr[i][j] = rand() % 10;
25 printf("%5d", arr[i][j]);
26
27 }
28 printf("\n");
29 }
30
31 for (i = N - 1, j = 0, count = 0; i >= j; j++, count++)//从左下方第N-1行第0列开始循环到对角线第N-1行第N-1列
32 {
33 sum = 0;//临时变量，存储反斜线上的元素之和
34 m = i;
35 n = j;
36
37 while (m >= 0 && n >= 0)//数组下标一定大于等于0
38 {
39 sum += arr[m][n];
40 m--;//向上-1
41 n--;//向上-1
42 }
43
44 arrSum[count] = sum;//记录反斜线上的元素之和
45
46 printf("arrSum[%d]=%d\n", count, sum);
47 }
48
49 for (i = N - 2, j = N - 1; i >= 0; i--, count++)//从对角线上方第N-2行第N-1列开始循环到第0行第N-1列
50 {
51 sum = 0;//临时变量，存储反斜线上的元素之和
52 m = i;
53 n = j;
54
55 while (m >= 0 && n >= 0)//数组下标一定大于等于0
56 {
57 sum += arr[m][n];
58 m--;//向上-1
59 n--;//向上-1
60 }
61
62 arrSum[count] = sum;//记录反斜线上的元素之和
63
64 printf("arrSum[%d]=%d\n", count, sum);
65 }
66
67 system("pause");
68 }
21 编写程序，按照 1,2, ... , 28的顺序填一个7×7数组的左上角，程序的输出结果为：
1 2 4 7 11 16 22
3 5 8 12 17 23
6 9 13 18 24
10 14 19 25
15 20 26
21 27
28
1 #include
2 #define N 7
3
4 void main()
5 {
6 int arr[N][N] = { 0 };
7 int i, j;//数组下标
8 int m = 0;//开始，第0行
9 int n = 0;//开始，第0列
10 int count = 0;//每循环一次斜线，+1
11
12 for (i = 1; i <= (N + 1)*N / 2; i++)//对角线左上角，含对角线
13 {
14 arr[m][n] = i;//赋值
15
16 if (n == 0)//每次循环到第0列，需要重置，横坐标为0，纵坐标+1
17 {
18 m = 0;//横坐标
19
20 count++;//纵坐标
21 n = count;
22 }
23 else
24 {
25 m++;
26 n--;
27 }
28 }
29
30 m = 1;//开始，第1行
31 n = N - 1;//开始，第N-1列
32 count = 1;//每过一次斜线，+1
33
34 for (i = (N + 1)*N / 2 + 1; i <= N*N; i++)//对角线右下角，不含对角线
35 {
36 arr[m][n] = i;//赋值
37
38 if (m == N - 1)//每次循环到第N-1行，需要重置，横坐标为+1，纵坐标为N-1
39 {
40 count++;//横坐标
41 m = count;
42
43 n = N - 1;////纵坐标
44 }
45 else
46 {
47 m++;
48 n--;
49 }
50 }
51
52 for (i = 0; i < N; i++)//打印
53 {
54 for (j = 0; j < N; j++)
55 {
56 printf("%5d", arr[i][j]);
57 }
58 printf("\n");
59 }
60 }
22 二维数组排序。设有4×5的数组M，通过排序使M[1][1]≤M[1][2]≤...≤M[1][5]≤M[2][1]≤M[2][2]≤...≤M[2][5]≤...≤M[4][1]≤M[4][2]≤...≤M[4][5]。排序时不允许引入其它数组。
1 #include
2 #include
3
4 #define N 4
5 #define M 5
6
7 void sort(int *p, int n, int m)//二维数组排序，冒泡
8 {
9 int i, j;//数组下标
10 int temp;
11
12 for (i = 0; i < n*m - 1; i++)//冒泡
13 {
14 for (j = 0; j < n*m - 1 - i; j++)
15 {
16 if (*(p + j)>*(p + j + 1))
17 {
18 temp = *(p + j);
19 *(p + j) = *(p + j + 1);
20 *(p + j + 1) = temp;
21 }
22 }
23 }
24 }
25
26 void print(int arr[][M], int n, int m)//打印二维数组
27 {
28 int i, j;
29
30 for (i = 0; i < n; i++)
31 {
32 for (j = 0; j < m; j++)
33 {
34 printf("%5d", arr[i][j]);
35 }
36 printf("\n");
37 }
38 }
39
40 void main()
41 {
42 time_t ts;
43 srand((unsigned int)time(&ts));
44 int arr[N][M] = { 0 };//初始化数组
45 int i, j;//数组下标
46
47 for (i = 0; i < N; i++)
48 {
49 for (j = 0; j < M; j++)
50 {
51 arr[i][j] = rand() % 100;//数组赋值
52 }
53 }
54
55 print(arr, N, M);//打印二维数组
56
57 printf("二维数组排序，冒泡\n");
58
59 sort(arr, N, M);//二维数组排序，冒泡
60
61 print(arr, N, M);//打印二维数组
62 }
123
