经典算法_数组

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 <di (i=k-1,k-2,...,1)，则称N是严格升序数；如果di+1 =di (i=k-1,k-2,...,1)，则称N是等序数；此外，则称N是无序数。例如， 4321是严格降序数，1234是严格升序数，2222是等序数，1243是无序数。从键盘上输入一个大于9的整数N，判它属于上述哪一类。

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 对一个一维数组进行按照元素的升序大小进行排序，冒泡排序法

#include<stdio.h>

void sort(int * a, int len)
{
    int i, j, t;
    for (i = 0;i < len - 1;++i)
    {
        for (j = 0;j < len - 1 - i;++j)
        {
            if (a[j] > a[j + 1])        /* >表示升序 <表示降序 */
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
}

main()
{
    int a[6] = { 10,2,8,-8,11,0 };
    int i = 0;

    sort(a, 6);

    for (i = 0;i < 6;++i)
    {
        printf("%d ", a[i]);
    }
    printf("
");
}

2 随机生成一个有10个元素的一维数组，并找出极值

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#include<time.h>


main()
{
    time_t ts;

    srand((unsigned int)time(&ts));

    int a[10];
    int i;
    int max;//用于保存最大值
    int maxi;//用于保存最大值的下标
    int min;
    int mini;

    for (i = 0;i < 10;i++)
    {
        a[i] = rand() % 100;
        printf("%d,%x
", a[i], &a[i]);
    }

    max = a[0];//假设第一个是最大的数
    maxi = 0;//
    min = a[0];//假设第一个是最小的数
    mini = 0;//

    for (i = 1;i < 10;i++)//选择比较
    {
        if (a[i] > max)
        {
            max = a[i];
            maxi = i;
        }
    }

    for (i = 1;i < 10;i++)//选择比较
    {
        if (a[i] < min)
        {
            min = a[i];
            mini = i;
        }
    }

    printf("最大值是%d，下标是%d
", max, maxi);
    printf("最小值是%d，下标是%d
", min, mini);

    system("pause");
}

3 将一个一维数组中n个整数按相反顺序存放

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 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("
");
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<stdio.h>
 4 #include<stdlib.h>
 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("
");
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<stdio.h>
 4 #include<stdlib.h>
 5 #include<time.h>
 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
", 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
", a[i]);
43     }
44     int *p = mindata(a, 10);
45 
46     //修改最小数
47     *p = 200;
48 
49     printf("
");
50     //查看修改以后的数组
51     for (i = 0;i < 10;i++)
52     {
53         printf("%d
", a[i]);
54     }
55 
56     system("pause");
57 }

  

6 不改变原有的一维数组排序，使用指针数组，进行排序，冒泡排序法

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 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("原有数组
");
15     for (i = 0;i < 5;i++)//下标循环的方式
16     {
17         printf("%d
", num[i]);
18     }
19     printf("
");
20 
21     printf("排序以前
");
22     for (i = 0;i < 5;i++)//下标循环的方式
23     {
24         printf("%d,%d
", *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
", **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("原有数组
");
46     for (i = 0;i < 5;i++)//下标循环的方式
47     {
48         printf("%d
", num[i]);
49     }
50     printf("
");
51 
52     printf("排序以后
");
53     for (i = 0;i < 5;i++)//下标循环的方式
54     {
55         printf("%d,%d
", *p[i], *(*(p + i)));//p[i]是一个地址，*p[i]取出内容
56     }//p[i]等价于*(p + i)
57 
58     system("pause");
59 }

7 一维数组的逆转

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>

void rev(int a[], int n)
{
    int i;
    int temp;

    for (i = 0;i < n / 2 - 1;i++)
    {
        temp = a[i];
        a[i] = a[n - 1 - i];
        a[n - 1 - i] = temp;
    }
}

void rev1(int *a, int n)//数组名作为形式参数，就是一个指针，所以用指针也没问题
{
    int i;
    int temp;

    for (i = 0;i < n / 2 - 1;i++)
    {
        temp = a[i];
        a[i] = a[n - 1 - i];
        a[n - 1 - i] = temp;
    }
}

void rev2(int *a, int n)//指针循环
{
    int i;
    int temp;

    for (i = 0;i < n / 2 - 1;i++)
    {
        temp = *(a + i);
        *(a + i) = *(a + n - 1 - i);
        *(a + n - 1 - i) = temp;
    }
}

void rev3(int a[], int n)
{
    int i;
    int temp;

    for (i = 0;i < n / 2 - 1;i++)
    {
        temp = *(a + i);
        *(a + i) = *(a + n - 1 - i);
        *(a + n - 1 - i) = temp;
    }
}

main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int *p = a;
    int i;
    int n = sizeof(a) / sizeof(int);
    
    for (i = 0;i < n;i++)
    {
        printf("%d
", a[i]);
    }

    //rev(a, n);
    //rev1(a, n);
    //rev2(a, n);
    rev3(p, n);

    printf("逆序
");
    for (i = 0;i < n;i++)
    {
        printf("%d
", a[i]);
    }

    system("pause");
};

8 有 N个数已按由小到大的顺序排好，要求输入一个数， 把它插入到原有序列中，而且仍然保持有序

#include<stdio.h>

#define N 11

void printarr(int arr[], int n)//打印数组
{
    int i;

    for (i = 0; i < n; i++)
    {
        printf("%4d", arr[i]);
    }

    printf("
");
}

main()
{
    int arr[N] = { 1,2,3,4,5,7,8,9,10,11 };
    int num = 6;//要插入的数
    int i;
    int j;

    printarr(arr, N - 1);//打印数组

    for (i = 0; i < N; i++)//外循环，遍历数组
    {
        if (arr[i] > num)//如果找到比插入的数更大的数
        {
            for (j = 9; j >= i; j--)//内循环，最后一位开始往后移动
            {
                arr[j + 1] = arr[j];
            }

            arr[i] = num;//插入

            break;//记得break，不然往后一直是要插入的数6
        }
    }

    printarr(arr, N);//打印数组

    system("pause");
}

9 用选择法对10个整数由大到小排序

#include<stdio.h>
#include<time.h>

#define N 10

void selectionsort(int arr[], int n)//选择排序法
{
    int i;
    int j;
    int max;//存储最大值下标

    for (i = 0; i < n - 1; i++)//外循环
    {
        max = i;//假设当前为最大值

        for (j = i + 1; j < n; j++)//内循环
        {
            if (arr[j] > arr[max])//如果找到更大值
            {
                max = j;//变更max
            }
        }

        if (max != i)//如果max发生变更，交换
        {
            arr[max] ^= arr[i];
            arr[i] ^= arr[max];
            arr[max] ^= arr[i];
        }
    }
}

main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[N] = { 0 };
    int i;

    for (i = 0; i < N; i++)
    {
        arr[i] = rand() % 1000;
        printf("arr[%d]=%d
", i, arr[i]);
    }

    selectionsort(arr, N);//选择排序法

    printf("after
");

    for (i = 0; i < N; i++)
    {
        printf("arr[%d]=%d
", i, arr[i]);
    }

    system("pause");
}

10 用筛选法求 2到 100之间的素数。方法如下：首先 2是素数，凡 2 的倍数都不是素数，于是把这些数从数表中筛去， 2以后没有被筛去的第一个数是 3， 然后把 3的倍数都从数表中筛去， 3以后没被筛去的第一个数是 5，然后把 5 的倍数都从数表中筛去。如此下去，直到遇到某数 K（≤ N），其后没有数可筛选为止， 这时保留下的未被筛去的数就是 2到 N的素数

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define N 101

main()
{
    int arr[N];//创建数组
    int i;//数组下标
    int j;//数组下标

    for (i = 0; i < N; i++)
    {
        arr[i] = 1;//初始化数组，先默认都是素数，1是素数，0不是素数
    }

    arr[0] = arr[1] = 0;//0和1不是素数

    for (i = 2; i < sqrt(N - 1); i++)//从2开始循环
    {
        while (!arr[i])//排除非素数，最后定向i为素数
        {
            i++;
        }

        for (j = i + i; j < N; j = j + i)//从i的2倍开始，每次递增倍数
        {
            arr[j] = 0;//i的倍数不是素数
        }
    }

    for (i = 0; i < N; i++)
    {
        if (arr[i])//1是素数，0不是素数
        {
            printf("%d
", i);
        }
    }

    system("pause");
}

11 有17个人围成一圈（编号为0～16），从第 0号的人开始从 1报数， 凡报到 3的倍数的人离开圈子，然后再数下去，直到最后只剩下一个人为止。 问此人原来的位置是多少号？

可以使用数组解决，也可以使用循环链表解决。这里使用数组解决。

i = i % length + 1;//利用求余%运算，i在1~length之间循环

index = (index + 1) % m;//利用求余%运算，index在0~m-1之间循环

#include <stdio.h>
#include <stdlib.h>

void main()
{
    int length = 17;//总人数17个人
    int m = 3;//报到 3的倍数的人离开圈子
    int index = 0;//报数
    int count = 0;//out的人数
    int i = 0;//数组下标
    int a[100] = { 0 };//初始化数组，0在场，1不在场

    while (1)//死循环，直到out的人数等于总人数
    {
        i = i % length + 1;//利用求余%运算，i在1~length之间循环

        if (a[i] == 0)//0在场，1不在场
        {
            index = (index + 1) % m;//利用求余%运算，index在0~m-1之间循环
            if (index == 0)
            {
                count++;//out的人数增加
                a[i] = 1;//0在场，1不在场
                printf("这次out的人原来的位置是%d号
", i);
            }
        }

        if (length == count)//死循环，直到out的人数等于总人数
        {
            break;
        }
    }

    system("pause");
}

12 打印所有不超过 n（ n<256）的其平方具有对称性的数（也称回文数）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

int getwei(int num)
{
    if (num < 10)
    {
        return 1;
    }
    else
    {
        return getwei(num / 10) + 1;
    }
}

int huiwen(int num)
{
    int i;
    int a[10] = { 0 };//初始化数组
    int wei = getwei(num);//得到位数
    int flag = 1;//1是回文数，0不是回文数

    for (i = 0; i < wei; i++)//不断取出数字，保存到数组
    {
        a[i] = num % 10;//取出最后一位
        num /= 10;//去掉最后一位，保留前面数字
    }

    for (i = 0; i < wei / 2; i++)//判断一半即可
    {
        if (a[i] != a[wei - 1 - i])//如果发现不是回文
        {
            flag = 0;//1是回文数，0不是回文数
            break;
        }
    }

    return flag;
}

void main()
{
    int i;
    int n = 256;

    for (i = 0; i < n; i++)
    {
        if (huiwen(i*i))
        {
            printf("%d * %d = %d
", i, i, i*i);
        }
    }

    system("pause");
}

13 求N个数中的最大值，最大值出现的次数，然后求出次大值（次大值一定存在）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 10

void searchMax1_Max2(int arr[], int num, int *pamx1, int *pamx2, int *pmax1_count)
{
    int i;
    *pamx1 = 0;//最大值，必须初始化为0
    *pamx2 = 0;//次大值，必须初始化为0
    
    for (i = 0; i < N; i++)
    {
        if (arr[i] > *pamx1)//找到比原来的最大值还大
        {
            *pmax1_count = 1;//恢复1
            *pamx2 = *pamx1;//原来的最大值变成次大值
            *pamx1 = arr[i];//保存新的最大值
        }
        else if (arr[i] == *pamx1)//找到重复的最大值
        {
            (*pmax1_count)++;//次数+1
        }
        else if (arr[i] > *pamx2 && arr[i] < *pamx1)//找到比原来的次大值还大，且比最大值还小
        {
            *pamx2 = arr[i];//保存新的次大值
        }
        else
        {
            continue;//继续循环
        }
    }
}

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int i;
    int arr[N] = { 0 };//初始化数组
    int max1 = 0;//保存最大值
    int max2 = 0; //保存次大值
    int max1_count = 1;//肯定存在最大值

    for (i = 0; i < N; i++)
    {
        arr[i] = rand() % 10;
        printf("arr[%d]=%d
", i, arr[i]);
    }

    searchMax1_Max2(arr, N, &max1, &max2, &max1_count);//寻找最大值，次大值，和最大值出现的次数

    printf("max1=%d,max2=%d,max1_count=%d", max1, max2, max1_count);

    system("pause");
}

14 圆盘上有如下图所示的二十个数，请找出哪四个相邻数之和为最大，并指出它们的起始位置及最大和的值。

一维数组模拟圆，使用%来实现圆的循环，类似出圈游戏

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

#define N 20

void main()
{
    int a[N] = { 20,1,8,4,13,6,10,15,2,17,3,19,7,16,8,11,14,9,12,5 };
    int b[N] = { 0 };///相邻四个数之和，放入b[N]
    int i;
    int max = 0;//保存最大值
    int index = 0;//保存最大值的下标

    for (i = 0; i < N; i++)
    {
        b[i] = a[i] + a[(i + 1) % N] + a[(i + 2) % N] + a[(i + 3) % N];//一维数组模拟圆，使用%来实现圆的循环，类似出圈游戏
    }

    max = b[0];

    for (i = 0; i < N; i++)
    {
        printf("b[%d]=%d
", i, b[i]);
    }

    for (i = 1; i < N; i++)
    {
        if (b[i] > max)
        {
            index = i;
            max = b[i];
        }
    }

    printf("index=%d,max=%d
", index + 1, max);

    system("pause");
}

15 将一个一维数组中的偶数依次交换。例如有8个元素， 若其中第1、4、5三元素是偶数时应按下图交换。

#include <stdio.h>
#include <stdlib.h>
#define N 8

int *getFirst(int arr[], int n)//返回第一个偶数的地址
{
    int *pFirst = NULL;//保存地址
    for (int *p = arr; p < arr + n; p++)//从前到后
    {
        if (!(*p % 2))
        {
            pFirst = p;
            break;
        }
    }
    return pFirst;
}

int *getLast(int arr[], int n)//返回最后一个偶数的地址
{
    int *pLast = NULL;//保存地址
    for (int *p = arr + n - 1; p >= arr; p--)//从后到前
    {
        if (!(*p % 2))
        {
            pLast = p;
            break;
        }
    }
    return pLast;
}

void main()
{
    int arr[N] = { 2,3,1,6,8,7,9,5 };//初始化数组
    int i;

    for (i = 0; i < N; i++)
    {
        printf("%5d", arr[i]);
    }

    int *pLast = getLast(arr, N);//返回最后一个偶数的地址
    int lastValue = *pLast;//保存最后一个偶数的值

    int *pFirst = getFirst(arr, N);//返回第一个偶数的地址

    for (int *p = pLast - 1; p >= pFirst; p--)//从最后一个偶数的前一个地址开始往前循环，到第一个偶数为止
    {
        if (!(*p % 2))
        {
            *pLast = *p;//往后赋值
            pLast = p;//将当前偶数赋给标识变量pLast
        }
    }

    *pFirst = lastValue;//第一个偶数的地址，需要赋上当初最后一个偶数的值

    printf("
调整以后
");
    for (i = 0; i < N; i++)
    {
        printf("%5d", arr[i]);
    }
    
    system("pause");
}

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

#include <stdio.h>
#include <stdlib.h>

#define N 8

void print(int arr[], int n)
{
    int i;

    for (i = 0; i < n; i++)
    {
        printf("%5d", arr[i]);
    }
    printf("
");
}

void main()
{
    int arr[N] = { 1,2,3,4,5,6,7,8 };
    int k = 3;
    int i;
    int temp = 0;
    int j;

    print(arr, N);

    for (i = 0; i < 3; i++)//第一步，对调前k项和后k项
    {
        temp = arr[i];
        arr[i] = arr[N - 1 - i];
        arr[N - 1 - i] = temp;
    }

    print(arr, N);//8 7 6 4 5 3 2 1

    for (i = 0; i < k / 2; i++)//第二步，前k项逆序
    {
        temp = arr[i];
        arr[i] = arr[k - 1 - i];
        arr[k - 1 - i] = temp;
    }

    print(arr, N);//6 7 8 4 5 3 2 1

    for (i = k; i < 2 * k; i++)
    {
        temp = arr[N - 1];//存储最后一个元素
                            
        for (j = N - 2; j > i - 1; j--)//后N - k - 1个元素向后移动
        {
            arr[j + 1] = arr[j];
        }
        arr[i] = temp;//原来最后一个元素向前

        print(arr, N);
    }
}

17 自然数N一般写成如下形式:

N=dk dk-1 d1 （d1～dk 均是十进制数字）

如果di+1 >di (i=k-1,k-2,...,1)，则称N是严格降序数；如果di+1 <di (i=k-1,k-2,...,1)，则称N是严格升序数；如果di+1 =di (i=k-1,k-2,...,1)，则称N是等序数；此外，则称N是无序数。例如， 4321是严格降序数，1234是严格升序数，2222是等序数，1243是无序数。从键盘上输入一个大于9的整数N，判它属于上述哪一类。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 10

int arr[N] = { 0 };//初始化数组0

int isequal(int n)//等序返回1
{
    if (n == 1)
    {
        return arr[n - 1] == arr[n];
    }
    else
    {
        return (arr[n - 1] == arr[n]) && isequal(n - 1);
    }
}

int isminus(int n)//降序返回1
{
    if (n == 1)
    {
        return arr[n - 1] > arr[n];
    }
    else
    {
        return (arr[n - 1] > arr[n]) && isminus(n - 1);
    }
}

int isadd(int n)//升序返回1
{
    if (n == 1)
    {
        return arr[n - 1] < arr[n];
    }
    else
    {
        return (arr[n - 1] < arr[n]) && isadd(n - 1);
    }
}

int getwei(int n)//返回整数位数
{
    if (n < 10)
    {
        return 1;
    }
    else
    {
        return getwei(n / 10) + 1;
    }
}

void arrSet(int arr[], int num)//把整数各位存放到数组
{
    memset(arr, -1, sizeof(arr));//初始化数组-1
    int i;
    int wei = getwei(num);//返回整数位数

    for (i = wei - 1; i >= 0; i--)//把整数各元素放入数组
    {
        arr[i] = num % 10 + 48;
        num /= 10;
    }
}

void arrJudge(int arr[], int num)//判断整数
{
    int wei = getwei(num);//返回整数位数

    if (num <= 9)
    {
        printf("从键盘上输入一个大于9的整数
");
    }
    else if (isadd(wei - 1))
    {
        printf("严格升序数
");
    }
    else if (isminus(wei - 1))
    {
        printf("严格降序数
");
    }
    else if (isequal(wei - 1))
    {
        printf("等序数
");
    }
    else
    {
        printf("无序数
");
    }
}

void main()
{
    int num = 1234;
    
    arrSet(arr, num);//把整数各位存放到数组

    arrJudge(arr, num);//判断整数
    
    system("pause");
}

18 已知A是有30个元素的整型数组，编写一个对A[I1]到A[I2]（I1≤I2）之间的元素排序的函数（从大到小排序）。请调用上述函数先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出。再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出。

要求：1) 输入输出均由主函数实现。

2) 输出时每10个元素占1行。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 30

void sortPart(int arr[], int n, int i1, int i2)//仅对arr[i1]->arr[i2]之间的元素进行排序，冒泡排序
{
    int i;
    int j;
    int temp;

    for (i = n - i2 - 1; i < n - 1; i++)//i = n - i2 - 1
    {
        for (j = i1; j < n - 1 - i; j++)//j = i1
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int A[N] = { 0 };//数组
    int i = 0;//数组下标
    int i1 = 0;//数组下标
    int i2 = 0;//数组下标

    for (i = 0; i < N; i++)//打印
    {
        A[i] = rand() % 100;//初始化数组

        printf("%5d", A[i]);

        if (!((i + 1) % 10))//输出时每10个元素占1行
        {
            printf("
");
        }
    }

    printf("先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出
");

    i1 = 5;//修改下标
    i2 = 20;//修改下标

    sortPart(A, N, i1, i2);//仅对i1至i2至今的元素进行排序，冒泡

    for (i = 0; i < N; i++)//打印
    {
        printf("%5d", A[i]);

        if (!((i + 1) % 10))//输出时每10个元素占1行
        {
            printf("
");
        }
    }

    printf("再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出
");

    i1 = 15;//修改下标
    i2 = 29;//修改下标

    sortPart(A, N, i1, i2);//仅对arr[i1]->arr[i2]之间的元素进行排序，冒泡排序

    for (i = 0; i < N; i++)//打印
    {
        printf("%5d", A[i]);

        if (!((i + 1) % 10))//输出时每10个元素占1行
        {
            printf("
");
        }
    }
}

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

#include <stdio.h>
#define N 10

int platformExist(int arr[], int n);//判断是否有最大平台
int platformOnly(int arr[], int n);//判断最大平台值是否为1
int platformBiggest(int arr[], int n);//获取最大平台值

void main()
{
    int arr[N] = { 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 };

    if (platformExist(arr, N))//判断是否有最大平台
    {
        if (platformOnly(arr, N))//判断最大平台值是否为1
        {
            printf("最大平台值为1
");
        }
        else
        {
            printf("最大平台值为%d
", platformBiggest(arr, N));//获取最大平台值
        }
    }
    else
    {
        printf("无最大平台
");
    }
}

int platformExist(int arr[], int n)//判断是否有最大平台
{
    int i = 0;//数组下标
    int flag = 1;//默认有最大平台

    for (i = 0; i < N - 1; i++)
    {
        if (arr[i] > arr[i + 1])
        {
            flag = 0;
            break;
        }
    }

    return flag;
}

int platformOnly(int arr[], int n)//判断最大平台值是否为1
{
    int i = 0;//数组下标
    int flag = 1;//默认最大平台值为1

    for (i = 0; i < N - 1; i++)
    {
        if (arr[i] == arr[i + 1])
        {
            flag = 0;
            break;
        }
    }

    return flag;
}

int platformBiggest(int arr[], int n)//获取最大平台值
{
    int i = 0;//数组下标
    int j = 0;//数组下标
    int max = 0;//保存最大平台值
    int s = 0;//临时变量

    for (i = 0; i < n; i++)
    {
        s = 0;

        for (j = i; j < n; j++)
        {
            if (arr[i] == arr[j])
            {
                s++;
            }

            if (s > max)
            {
                max = s;
            }
        }
    }

    return max;
}

20 某桔农家共有2520只桔子, 父亲要将它们分给六个儿子，其分法如下：父亲先将2520只桔子分给六个儿子, 然后说：“老大，把你分到的桔子的八分之一给老二；老二拿到以后，连同原来的桔子分出七分之一给老三；老三拿到以后，连同原来的桔子分出六分之一给老四；老四拿到以后，连同原来的桔子分出五分之一给老五；老五拿到以后，连同原来的桔子分出四分之一给老六；老六拿到以后，连同原来的桔子分出三分之一给老大”。这样分完之后，六个儿子手里的桔子正好一样多。问六个儿子原先分到的桔子各是多少只？

#include <stdio.h>
#define N 6

void main()
{
    const int total = 2520;//共有2520只桔子
    int arr[N] = { 0 };//初始化数组
    int i;//数组下标

    for (i = 0; i < N; i++)//最终结果每人一样
    {
        arr[i] = total / N;
    }

    arr[0] = arr[0] - arr[5] / 2;//老大接受老六的馈赠后便等于2520/6,故初始化老大的送完老二后的值

    for (i = 5; i > 0; i--)
    {
        arr[i] = arr[i] + arr[i] / (7 - i) - arr[i] / (8 - i);
    }

    arr[0] = arr[0] + arr[0] / 7;///加上开始送给老二的桔子

    for (i = 0; i < N; i++)//打印
    {
        printf("第%d个人原先分到的桔子是%d只
", i + 1, arr[i]);
    }
}

21 间隔元素排序。用随机函数产生25个[25,75]之间的整数， 把它送到一维数组M中。要求对M[I],M[I+J],M[I+2*J],…这些元素按从小到大的顺序排序。J的值由键盘输入，I从1到J变化。实际上是以J为间隔排了J个对列，每个对列中从小到大排序。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 25

void print(int arr[], int n);//打印数组
void sortJ(int arr[], int n, int j);//间隔元素排序

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[N] = { 0 };//初始化数组
    int i;//数组下标
    int j = 11;//间隔

    for (i = 0; i < N; i++)
    {
        arr[i] = rand() % 100;//赋值
    }

    print(arr, N);//打印数组

    printf("间隔元素排序
");

    sortJ(arr, N, j);//间隔元素排序

    print(arr, N);//打印数组
}

void print(int arr[], int n)//打印数组
{
    int i;//数组下标

    for (i = 0; i < n; i++)
    {
        printf("%5d", arr[i]);
        if ((i + 1) % 5 == 0)
        {
            printf("
");
        }
    }
}

void sortJ(int arr[], int n, int j)//间隔元素排序
{
    int i = 0;//数组下标
    int p = 0;//数组下标
    int q = 0;//数组下标
    int temp = 0;//临时

    for (i = 0; i < n; i += j)//外循环，间隔
    {
        for (p = i; p < i + j - 1 && p < n; p++)//内循环，排序，注意不要越界
        {
            for (q = i; q < i + j - 1 && q < n - 1; q++)//内循环，排序，注意不要越界
            {
                if (arr[q] > arr[q + 1])
                {
                    temp = arr[q];
                    arr[q] = arr[q + 1];
                    arr[q + 1] = temp;
                }
            }
        }
    }
}

22 求阶乘N!。

设输入的N最大可使N!达到100位，要求打印出全部有效数字。方法如下：用数组M[100]代表一个100位的数。M[1]代表最高位，M[100] 代表最低位。先对M[100]置1，其余各元素置零，然后从1到N进行累乘。同通常作乘法一样，数组M与I（1≤I≤N）相乘时，从低位数乘起，乘积大于9时进到上一位去，然后将结果打印（从头一个不等于零的位开始）。

#include <stdio.h>
#include <stdlib.h>

void main()
{
    int M[100] = { 0 };//用数组M[100]代表一个100位的数
    M[99] = 1;//先对M[99]置1
    int i = 1;//1至100阶乘N!
    int j = 99;//数组下标
    int JW = 0;//进位
    int num = 0;//临时乘积

    for (i = 1; i < 100; i++)
    {
        JW = 0;//进位置为0

        for (j = 99; j >= 0; j--)
        {
            int num = M[j] * i + JW;

            if (num > 9)//如果大于9，需要进位
            {
                M[j] = num % 10;//保存个位数
                JW = num / 10;//进位
            }
            else
            {
                M[j] = M[j] * i + JW;
                JW = 0;//进位置为0
            }
        }
    }

    i = 0;
    while (M[i] == 0)//从头一个不等于零的位开始
    {
        i++;
    }
        
    while (i < 100)//打印结果
    {
        printf("%d ", M[i]);
        i++;
    }
}

23 编写“N个人放鞭炮问题的程序”。

N个人同时刻开始放鞭炮， 第一个人每隔T1秒放一次，第二个人每隔T2秒放一次，...第N个人每隔Tn秒放一次。每个人各放M个鞭炮。问总共能听到多少次鞭炮声。

#include <stdio.h>
#include <stdlib.h>

#define N 5//N个人
#define M 10//每个人各放M个鞭炮

void main()
{
    int arr[N*M] = { 0 };//数组的元素个数是N*M，1代表听到鞭炮声，0代表没有听到鞭炮声
    int i = 0;//临时变量，用于循环
    int j = 0;//临时变量，用于循环
    int k = 0;//临时变量，用于循环
    int count = 0;//计数器
    int cnt = 0;//计数器

    for (i = 0; i < N; i++)//外循环，N个人
    {
        count = 0;//计数器
        j = 0;//每次从0开始听到鞭炮声
        k++;//每隔k秒放一次

        while (count < M)//内循环，每个人各放M个鞭炮
        {
            arr[j] = 1;//1代表听到鞭炮声，0代表没有听到鞭炮声
            j += k;//秒数+k
            count++;//计数器
        }
    }

    for (i = 0; i < N*M; i++)//循环，查找有听到鞭炮声的秒数
    {
        if (arr[i])
        {
            cnt++;//计数器
            printf("%d ", i);//打印有听到鞭炮声的秒数
        }
    }

    printf("总共能听到%d次鞭炮声
", cnt);
}

24 十个数字组成完全平方数。

把0、1、2、3、4、5、6、7、8、9十个数字分别组成一个一位数，一个二位数，一个三位数和一个四位数，使它们都是完全平方数（其平方根是整数），共有几种方法? 每种方法的结果是什么? （每个数字只允许用一次）。下边就是一种填法：

１ （ １ ）

３６ （ ６ ）

７８４ （ ２８ ）

９０２５ （ ９５ ）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool fillarr(int *arr, int num)
{
    int temp = 0;//临时变量

    if (num)//如果不是0
    {
        while (num)
        {
            temp = num % 10;//取出个位数
            if (!arr[temp])//如果该下标没有被占用
            {
                arr[temp] = 1;//占用
            }
            else
            {
                return false;
            }
            num /= 10;//去掉个位数
        }
    }
    else//如果是0
    {
        if (!arr[num])//如果该下标没有被占用
        {
            arr[num] = 1;//占用
        }
        else
        {
            return false;
        }
    }

    return true;
}

void main()
{
    int count = 0;//计数器
    int arr[10] = { 0 };//初始化数组，10个数字，10个元素，下标一一对应，1代表已经占用，0代表没有占用
    int i = 0;
    int j = 0;
    int k = 0;
    int l = 0;

    for (i = 0; i < 4; i++)//一位数，临界值0*0==0，3*3==9
    {
        for (j = 4; j < 10; j++)//两位数，临界值4*4==16，9*9==81
        {
            for (k = 10; k < 32; k++)//三位数，临界值10*10==100，31*31==961
            {
                for (l = 32; l < 100; l++)//四位数，临界值32*32==1024，99*99==9801
                {
                    memset(arr, 0, sizeof(arr));//清零
                    if (fillarr(arr, i*i) && fillarr(arr, j*j) && fillarr(arr, k*k) && fillarr(arr, l*l))//判断
                    {
                        count++;//计数器
                        printf("%d(%d) %d(%d) %d(%d) %d(%d)
", i*i, i, j*j, j, k*k, k, l*l, l);
                    }
                }
            }
        }
    }

    printf("共有%d种方法
", count);
}

------------------------------二维数组

9 对一个二维数组进行转置

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>

main()
{
    int a[3][4] = { 1,2,3,4,5,6,7,8,0,1,2,3 };
    int i, j;
    int b[4][3];//存储转置后的数据

    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 4;j++)
        {
            printf("%-5d", a[i][j]);
        }
        printf("
");
    }

    printf("以下是转置
");

    for (i = 0;i < 4;i++)
    {
        for (j = 0;j < 3;j++)
        {
            b[i][j] = a[j][i];
            printf("%-5d", b[i][j]);
        }
        printf("
");
    }

    system("pause");
}

10 打印杨辉三角形，包括直角三角形和等腰三角形

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>

#define N 10

main()
{
    int a[N][N] = { 0 };
    int i, j;

    for (i = 0;i < N;i++)
    {
        for (j = 0;j <= i;j++)
        {
            if (j == 0 || i == j)
            {
                a[i][j] = 1;
            }
            else
            {
                a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
            }
            printf("%5d", a[i][j]);
        }
        printf("
");
    }

    printf("输出等腰三角形
");


    for (i = 0;i < N;i++)
    {
        printf("%*d", 30 - i * 2, a[i][0]);//打印第一列，30是随意值，30 - i * 2，2必须是下下行的一半
        for (j = 1;j <= i;j++)
        {
            printf("%4d", a[i][j]);//%4d，4个字符的宽度，必须为上上行的2倍
        }
        printf("
");
    }

    system("pause");
}

11 有一个班，3个学生，各学4门课，计算总平均分以及第n个学生的成绩。查找有一门以上课程不及格的学生，输出该学生的所有成绩

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>

void avg(int(*p)[4], int n)//用指向数组的指针存储二维数组名，传递多少个元素（一维数组）
{
    int i, j;
    double res = 0;

    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 4;j++)
        {
            res += p[i][j];
        }
    }

    res /= 12;
    printf("%f
", res);
}

void show(int(*p)[4], int num)
{
    int i;

    for (i = 0;i < 4;i++)
    {
        printf("%6d", p[num][i]);//打印num行的所有数据
    }
}

void fail(int(*p)[4])
{
    int i, j;
    int flag = 1;//假设及格=1

    for (i = 0;i < 3;i++)
    {
        flag = 1;
        for (j = 0;j < 4;j++)
        {
            if (p[i][j] < 60)
            {
                flag = 0;//检测到不及格就退出循环
                break;
            }
        }
        if (flag == 0)//检测到不及格就全部打印
        {
            for (j = 0;j < 4;j++)
            {
                printf("%5d", p[i][j]);
            }
            printf("
");
        }
    }
}

main()
{
    int a[3][4] = { {45,68,97,68},{89,67,65,99},{100,89,98,86} };
    int num;
    avg(a, 3);

    //scanf("%d", &num);
    //show(a, num);

    fail(a);

    system("pause");
}

12 打印如下形式的杨辉三角形

              1

              1   1

              1   2   1

              1   3   3   1

              1   4   6   4   1

              1   5   10  10  5   1

输出前10行，从 0行开始，分别用一维数组和二维数组实现

二维数组

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

#define N 10

void main()
{
    int arr[N][N] = { 0 };//初始化数组
    int i;
    int j;

    for (i = 0; i < N; i++)
    {
        for (j = 0; j <= i; j++)//对角线左下
        {
            if (j == 0 || i == j)
            {
                arr[i][j] = 1;//如果是每行第0列或者是对角线上，为1
            }
            else
            {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];//其他为上一行上一列arr[i - 1][j - 1]和上一行本列arr[i - 1][j]之和
            }
            printf("%6d", arr[i][j]);
        }
        printf("
");
    }

    system("pause");
}

13 把一个二维实型数组a按照第0列的元素进行排序（由小到大排序，用起泡法）。例如：如果a[i][0]大于a[i+1][0]，则i行与i+1行中所有元素都要进行对换

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 10

void zhizhen_myswap(int(*arr)[N], int n, int num1, int num2)//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用指针
{
    int i;
    int temp;

    for (i = 0; i < n; i++)
    {
        temp = *(*(arr + num1) + i);
        *(*(arr + num1) + i) = *(*(arr + num2) + i);
        *(*(arr + num2) + i) = temp;
    }
}

void xiabiao_myswap(int arr[][N], int n, int num1, int num2)//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用数组下标
{
    int i;

    for (i = 0; i < n; i++)
    {
        arr[num1][i] ^= arr[num2][i];
        arr[num2][i] ^= arr[num1][i];
        arr[num1][i] ^= arr[num2][i];
    }
}

main()
{
    int i;
    int j;
    int arr[N][N] = { 0 };//初始化二维数组
    time_t ts;
    srand((unsigned int)time(&ts));

    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            arr[i][j] = rand() % 100;
            printf("%6d", arr[i][j]);
        }
        printf("
");
    }

    for (i = 0; i < N - 1; i++)
    {
        for (j = 0; j < N - 1 - i; j++)
        {
            if (arr[j][0]>arr[j + 1][0])
            {
                //xiabiao_myswap(arr, 10, j, j + 1);//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用数组下标
                zhizhen_myswap(arr, 10, j, j + 1);//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用指针
            }
        }
    }

    printf("after
");

    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            printf("%6d", arr[i][j]);
        }
        printf("
");
    }


    system("pause");
}

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

        要求：不允许使用键盘输入语句和静态赋值语句，尽量少用循环。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

#define N 7

main()
{
    int a[N][N] = { 0 };//初始化数组
    int i;
    int j;

    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            if (i == j || i + j == 6)//两条对角线为1
            {
                a[i][j] = 1;
            }
            else if (i < j && i + j < 6)//上边为2
            {
                a[i][j] = 2;
            }
            else if (i > j && i + j < 6)//左边为3
            {
                a[i][j] = 3;
            }
            else if (i < j && i + j > 6)//右边为4
            {
                a[i][j] = 4;
            }
            else//其他，即是下边为5
            {
                a[i][j] = 5;
            }
            printf("%2d", a[i][j]);
        }
        printf("
");
    }

    system("pause");
}

15 找出 M×N 数组中所有不相邻元素，并求出它们的和（相邻的数：前一个是偶数，后一个是素数）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#define M 10
#define N 10

int jiou(int num)//1是奇数，0是偶数
{
    return num % 2;
}

int isprime(int num)//1是素数，0不是素数
{
    int flag = 1;
    int i;

    if (num < 2)
    {
        flag = 0;
    }
    else if (num == 2)
    {
        flag = 1;
    }
    else
    {
        for (i = 2; i <= sqrt(num); i++)
        {
            if (!(num%i))
            {
                flag = 0;
                break;
            }
        }
    }

    return flag;
}

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[M][N] = { 0 };//初始化数组
    int i;//数组下标
    int j;//数组下标
    int flag = 0;//1是符合，0不符合
    int sum = 0;//和

    for (i = 0; i < M; i++)
    {
        for (j = 0; j < N; j++)
        {
            arr[i][j] = rand() % 100;//随机赋值
            printf("%5d", arr[i][j]);//打印
        }
        printf("
");
    }

    int *p = &arr[0][0];//指针，指向第一个元素的地址

    if (!jiou(*(p)) && isprime(*(p + 1)))//判断第一个元素，如果第一个元素是偶数，第二个元素是素数
    {
        sum += *(p);
        printf("0,%d
", *(p));
    }

    for (i = 1; i < M*N - 1; i++)//从第二个元素开始循环，直到倒数第二个元素
    {
        flag = 0;//默认不符合

        if (!jiou(*(p + i - 1)) && isprime(*(p + i)))//如果前一个是偶数，它本是素数
        {
            flag = 1;
        }
        else if (!jiou(*(p + i)) && isprime(*(p + i + 1)))//如果它本是偶数，后一个是素数
        {
            flag = 1;
        }

        if (flag == 1)
        {
            sum += *(p + i);
            printf("%d,%d
", i, *(p + i));
        }
    }

    if (!jiou(*(p + M*N - 2)) && isprime(*(p + M*N - 1)))//判断最后一个元素，如果倒数第二个元素是偶数，最后一个元素是素数
    {
        sum += *(p + M*N - 1);
        printf("%d,%d
", i, *(p + M*N - 1));
    }

    printf("sum=%d
", sum);

    system("pause");
}

16 打印魔方阵。所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。例如：三阶魔方阵为

                        8  1  6

                        3  5  7

                        4  9  2

    要求打印由 1到的自然数构成的魔方阵。

    提示：魔方阵中各数的排列规律如下：

      ⑴  将“1”放在第一行中间一列；

      ⑵  从“2”开始直到n×n为止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1；

      ⑶  如果上一个数的行数为1，则下一个数的行数为 n（指最下一行）；

      ⑷  当一个数的列数为 n，下一个数的列数应为1，行数减1；

      ⑸  如果按上面规则确定的位置已有数，或上一个数是第 1行第 n列时， 则把下一个数放在上一个数的下面。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

#define N 3//N可以为任何奇数，因为偶数矩阵没有对角线，故不符合题意

void main() 
{
    int a[N][N] = { 0 };//初始化数组
    int num = 1;//⑴  将“1”放在第一行中间一列；

    int i = 0;//⑴  将“1”放在第一行中间一列；
    int j = N / 2;//⑴  将“1”放在第一行中间一列；

    int ci = 0;
    int cj = 0;

    for (num = 1; num <= N*N; num++)
    {
        a[i][j] = num;//保存数字
        ci = i;//保存上一个数字的位置
        cj = j;//保存上一个数字的位置
        
        i = ci - 1;//⑵  从“2”开始直到n×n为止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1；
        j = cj + 1;

        if (ci == 0)//⑶  如果上一个数的行数为1，则下一个数的行数为 n（指最下一行）；
        {
            i = N - 1;
        }

        if (cj == N - 1)//⑷  当一个数的列数为 n，下一个数的列数应为1，行数减1；
        {
            j = 0;
            i = ci - 1;
        }

        if (a[i][j] != 0 || ci == 0 && cj == N - 1)//⑸  如果按上面规则确定的位置已有数，或上一个数是第 1行第 n列时， 则把下一个数放在上一个数的下面。
        {
            i = ci + 1;
            j = cj;
        }
    }

    for (i = 0; i < N; i++)//打印数组
    {
        for (j = 0; j < N; j++)
        {
            printf("%5d", a[i][j]);
        }
        printf("
");
    }

    system("pause");
}

17 找规律，编程序打印6×6的矩阵:

   1   2   3   5   8   13

   1   4   9  17  30   51

   1   6  19  45  92  173

       . . .

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

#define N 6

void main()
{
    int arr[N][N] = { 0 };
    int i;
    int j;

    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            if (j == 0)//第0列是1
            {
                arr[i][j] = 1;
                printf("%5d", arr[i][j]);
            }
            else if (i == 0)//第0行
            {
                if (j == 1)//第0行第1列是2
                {
                    arr[i][j] = 2;
                }
                else//第0行是从第2列开始前2列之和
                {
                    arr[i][j] = arr[i][j - 1] + arr[i][j - 2];
                }
                printf("%5d", arr[i][j]);
            }
            else
            {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j] + arr[i][j - 1];//其他是左上方，上方，左方之和
                printf("%5d", arr[i][j]);
            }
        }
        printf("
");
    }
}

18 已知M1是3×5的矩阵, M2是5×2的矩阵, 编程序求出M1与M2之积。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int M1[3][5] = { 0 };
    int M2[5][2] = { 0 };
    int M3[3][2] = { 0 };
    int i;
    int j;
    int k;
    int sum = 0;

    for (i = 0; i < 3; i++)//数组M1赋值
    {
        for (j = 0; j < 5; j++)
        {
            M1[i][j] = rand() % 2;
            printf("%5d", M1[i][j]);
        }
        printf("
");
    }

    printf("

");

    for (i = 0; i < 5; i++)//数组M2赋值
    {
        for (j = 0; j < 2; j++)
        {
            M2[i][j] = rand() % 2;
            printf("%5d", M2[i][j]);
        }
        printf("
");
    }

    printf("

");

    for (i = 0; i < 3; i++)//计算数组M3
    {
        for (j = 0; j < 2; j++)
        {
            sum = 0;
            for (k = 0; k < 5; k++)
            {
                sum += M1[i][k] * M2[k][j];
            }
            M3[i][j] = sum;
        }
    }

    for (i = 0; i < 3; i++)//打印
    {
        for (j = 0; j < 2; j++)
        {
            printf("%5d", M3[i][j]);
        }
        printf("
");
    }

    system("pause");
}

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

#include <stdio.h>
#include <stdlib.h>

#define N 8

void main()
{
    int a[N][N] = { 0 };

    int i;
    int j;
    int k;
    int u;
    int v;
    int data = 1;

    for (i = 0, j = 0, k = 0; k < (N + 1) / 2; k++, data++)
    {
        while (i < N - k)//左列赋值
        {
            a[i][j] = data;
            i = i + 1;
        }
        i--;
        j++;

        while (j < N - k)//下行赋值
        {
            a[i][j] = data;
            j = j + 1;
        }
        j--;
        i--;

        while (i > k - 1)//右列赋值
        {
            a[i][j] = data;
            i = i - 1;
        }
        i++;
        j--;

        while (j > k)//上行赋值
        {
            a[i][j] = data;
            j = j - 1;
        }
        i++;
        j++;
    }

    for (u = 0; u < N; u++)//打印
    {

        for (v = 0; v < N; v++)
        {
            printf("%d	", a[u][v]);

        }
        printf("
");
    }

    system("pause");
}

20 求N阶方阵（即N×N数组）中各条反斜线上的元素之和。如4×4数组共有7条反斜线：

注：求和时，请按斜线编号顺序显示求出的和。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 4

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[N][N] = { 0 };//初始化数组
    int arrSum[2 * N - 1] = { 0 };//初始化数组，存储各条反斜线上的元素之和
    int i;//数组下标
    int j;;//数组下标
    int sum = 0;//临时变量，存储反斜线上的元素之和
    int m;//数组下标
    int n;//数组下标
    int count = 0;//存储各条反斜线上的编号

    for (int i = 0; i < N; i++)//随机赋值
    {
        for (int j = 0; j < N; j++)
        {
            arr[i][j] = rand() % 10;
            printf("%5d", arr[i][j]);

        }
        printf("
");
    }

    for (i = N - 1, j = 0, count = 0; i >= j; j++, count++)//从左下方第N-1行第0列开始循环到对角线第N-1行第N-1列
    {
        sum = 0;//临时变量，存储反斜线上的元素之和
        m = i;
        n = j;

        while (m >= 0 && n >= 0)//数组下标一定大于等于0
        {
            sum += arr[m][n];
            m--;//向上-1
            n--;//向上-1
        }

        arrSum[count] = sum;//记录反斜线上的元素之和

        printf("arrSum[%d]=%d
", count, sum);
    }

    for (i = N - 2, j = N - 1; i >= 0; i--, count++)//从对角线上方第N-2行第N-1列开始循环到第0行第N-1列
    {
        sum = 0;//临时变量，存储反斜线上的元素之和
        m = i;
        n = j;

        while (m >= 0 && n >= 0)//数组下标一定大于等于0
        {
            sum += arr[m][n];
            m--;//向上-1
            n--;//向上-1
        }

        arrSum[count] = sum;//记录反斜线上的元素之和

        printf("arrSum[%d]=%d
", count, sum);
    }

    system("pause");
}

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

#include <stdio.h>
#define N 7

void main()
{
    int arr[N][N] = { 0 };
    int i, j;//数组下标
    int m = 0;//开始，第0行
    int n = 0;//开始，第0列
    int count = 0;//每循环一次斜线，+1

    for (i = 1; i <= (N + 1)*N / 2; i++)//对角线左上角，含对角线
    {
        arr[m][n] = i;//赋值

        if (n == 0)//每次循环到第0列，需要重置，横坐标为0，纵坐标+1
        {
            m = 0;//横坐标

            count++;//纵坐标
            n = count;
        }
        else
        {
            m++;
            n--;
        }
    }

    m = 1;//开始，第1行
    n = N - 1;//开始，第N-1列
    count = 1;//每过一次斜线，+1

    for (i = (N + 1)*N / 2 + 1; i <= N*N; i++)//对角线右下角，不含对角线
    {
        arr[m][n] = i;//赋值

        if (m == N - 1)//每次循环到第N-1行，需要重置，横坐标为+1，纵坐标为N-1
        {
            count++;//横坐标
            m = count;

            n = N - 1;////纵坐标
        }
        else
        {
            m++;
            n--;
        }
    }

    for (i = 0; i < N; i++)//打印
    {
        for (j = 0; j < N; j++)
        {
            printf("%5d", arr[i][j]);
        }
        printf("
");
    }
}

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]。排序时不允许引入其它数组。

#include <stdio.h>
#include <time.h>

#define N 4
#define M 5

void sort(int *p, int n, int m)//二维数组排序，冒泡
{
    int i, j;//数组下标
    int temp;

    for (i = 0; i < n*m - 1; i++)//冒泡
    {
        for (j = 0; j < n*m - 1 - i; j++)
        {
            if (*(p + j)>*(p + j + 1))
            {
                temp = *(p + j);
                *(p + j) = *(p + j + 1);
                *(p + j + 1) = temp;
            }
        }
    }
}

void print(int arr[][M], int n, int m)//打印二维数组
{
    int i, j;

    for (i = 0; i < n; i++)
    {
        for (j = 0; j < m; j++)
        {
            printf("%5d", arr[i][j]);
        }
        printf("
");
    }
}

void main()
{
    time_t ts;
    srand((unsigned int)time(&ts));
    int arr[N][M] = { 0 };//初始化数组
    int i, j;//数组下标

    for (i = 0; i < N; i++)
    {
        for (j = 0; j < M; j++)
        {
            arr[i][j] = rand() % 100;//数组赋值
        }
    }

    print(arr, N, M);//打印二维数组

    printf("二维数组排序，冒泡
");

    sort(arr, N, M);//二维数组排序，冒泡

    print(arr, N, M);//打印二维数组
}

123