经典算法_数组

1 #include<stdio.h>
2 
3 void sort(int * a, intlen)
4 {
5     inti, 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("");
32 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include<stdio.h>
4 #include<stdlib.h>
5 #include<time.h>
6 
7 
8 main()
9 {
10 time_t ts;
11 
12     srand((unsigned int)time(&ts));
13 
14     int a[10];
15     inti;
16     int max;//用于保存最大值
17     int maxi;//用于保存最大值的下标
18     intmin;
19     intmini;
20 
21     for (i = 0;i < 10;i++)
22 {
23         a[i] = rand() % 100;
24         printf("%d,%x
", 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
", max, maxi);
51     printf("最小值是%d，下标是%d
", min, mini);
52 
53     system("pause");
54 }

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 void change(int a[], intn)
 7 {
 8     inti;
 9     inttemp;
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     inti;
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 }

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdio.h>
 4 #include<stdlib.h>
 5 
 6 void sort(int *p, intn)
 7 {
 8     inti, j;
 9     inttemp;
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     inti;
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 }

 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     inti;
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     returnp;
28 }
29 
30 main()
31 {
32 time_t ts;
33     srand((unsigned int)time(&ts));
34     
35     int a[10];
36     inti;
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 }

 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     inti, 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 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include<stdio.h>
4 #include<stdlib.h>
5 
6 void rev(int a[], intn)
7 {
8     inti;
9     inttemp;
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     inti;
22     inttemp;
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     inti;
35     inttemp;
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[], intn)
46 {
47     inti;
48     inttemp;
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     inti;
63     int n = sizeof(a) / sizeof(int);
64     
65     for (i = 0;i < n;i++)
66 {
67         printf("%d
", a[i]);
68 }
69 
70     //rev(a, n);
71     //rev1(a, n);
72     //rev2(a, n);
73 rev3(p, n);
74 
75     printf("逆序
");
76     for (i = 0;i < n;i++)
77 {
78         printf("%d
", a[i]);
79 }
80 
81     system("pause");
82 };

1 #include<stdio.h>
2 
3 #define N 11
4 
5 void printarr(int arr[], int n)//打印数组
6 {
7     inti;
8 
9     for (i = 0; i < n; i++)
10 {
11         printf("%4d", arr[i]);
12 }
13 
14     printf("");
15 }
16 
17 main()
18 {
19     int arr[N] = { 1,2,3,4,5,7,8,9,10,11};
20     int num = 6;//要插入的数
21     inti;
22     intj;
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 }

1 #include<stdio.h>
2 #include<time.h>
3 
4 #define N 10
5 
6 void selectionsort(int arr[], int n)//选择排序法
7 {
8     inti;
9     intj;
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     inti;
39 
40     for (i = 0; i < N; i++)
41 {
42         arr[i] = rand() % 1000;
43         printf("arr[%d]=%d
", i, arr[i]);
44 }
45 
46     selectionsort(arr, N);//选择排序法
47 
48     printf("after
");
49 
50     for (i = 0; i < N; i++)
51 {
52         printf("arr[%d]=%d
", i, arr[i]);
53 }
54 
55     system("pause");
56 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <math.h>
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
", i);
40 }
41 }
42 
43     system("pause");
44 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 
4 voidmain()
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号
", i);
25 }
26 }
27 
28         if (length == count)//死循环，直到out的人数等于总人数
29 {
30             break;
31 }
32 }
33 
34     system("pause");
35 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 
6 int getwei(intnum)
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(intnum)
19 {
20     inti;
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     returnflag;
41 }
42 
43 voidmain()
44 {
45     inti;
46     int n = 256;
47 
48     for (i = 0; i < n; i++)
49 {
50         if (huiwen(i*i))
51 {
52             printf("%d * %d = %d
", i, i, i*i);
53 }
54 }
55 
56     system("pause");
57 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <time.h>
6 
7 #define N 10
8 
9 void searchMax1_Max2(int arr[], int num, int *pamx1, int *pamx2, int *pmax1_count)
10 {
11     inti;
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 voidmain()
39 {
40 time_t ts;
41     srand((unsigned int)time(&ts));
42     inti;
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
", 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 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 
6 #define N 20
7 
8 voidmain()
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     inti;
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
", 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
", index + 1, max);
38 
39     system("pause");
40 }

1 #include <stdio.h>
2 #include <stdlib.h>
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     returnpFirst;
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     returnpLast;
31 }
32 
33 voidmain()
34 {
35     int arr[N] = { 2,3,1,6,8,7,9,5 };//初始化数组
36     inti;
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("调整以后
");
60     for (i = 0; i < N; i++)
61 {
62         printf("%5d", arr[i]);
63 }
64     
65     system("pause");
66 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 
4 #define N 8
5 
6 void print(int arr[], intn)
7 {
8     inti;
9 
10     for (i = 0; i < n; i++)
11 {
12         printf("%5d", arr[i]);
13 }
14     printf("");
15 }
16 
17 voidmain()
18 {
19     int arr[N] = { 1,2,3,4,5,6,7,8};
20     int k = 3;
21     inti;
22     int temp = 0;
23     intj;
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 }

1 #include <stdio.h>
2 #include <stdlib.h>
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     inti;
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的整数
");
77 }
78     else if (isadd(wei - 1))
79 {
80         printf("严格升序数
");
81 }
82     else if (isminus(wei - 1))
83 {
84         printf("严格降序数
");
85 }
86     else if (isequal(wei - 1))
87 {
88         printf("等序数
");
89 }
90     else
91 {
92         printf("无序数
");
93 }
94 }
95 
96 voidmain()
97 {
98     int num = 1234;
99     
100     arrSet(arr, num);//把整数各位存放到数组
101 
102     arrJudge(arr, num);//判断整数
103     
104     system("pause");
105 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 
5 #define N 30
6 
7 void sortPart(int arr[], int n, int i1, int i2)//仅对arr[i1]->arr[i2]之间的元素进行排序，冒泡排序
8 {
9     inti;
10     intj;
11     inttemp;
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 voidmain()
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("");
45 }
46 }
47 
48     printf("先将A[5]至A[20]之间的元素排序，然后将A中的所有元素值输出
");
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("");
62 }
63 }
64 
65     printf("再调用上述函数对A[15]至A[29]之间的元素排序，最后再将A中30个元素值输出
");
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("");
79 }
80 }
81 }

1 #include <stdio.h>
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 voidmain()
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
");
17 }
18         else
19 {
20             printf("最大平台值为%d
", platformBiggest(arr, N));//获取最大平台值
21 }
22 }
23     else
24 {
25         printf("无最大平台
");
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     returnflag;
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     returnflag;
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     returnmax;
89 }

1 #include <stdio.h>
2 #define N 6
3 
4 voidmain()
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只
", i + 1, arr[i]);
27 }
28 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 #define N 25
5 
6 void print(int arr[], int n);//打印数组
7 void sortJ(int arr[], int n, int j);//间隔元素排序
8 
9 voidmain()
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("间隔元素排序
");
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("");
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 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 
4 voidmain()
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 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 
4 #define N 5//N个人
5 #define M 10//每个人各放M个鞭炮
6 
7 voidmain()
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次鞭炮声
", cnt);
40 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <stdbool.h>
5 
6 bool fillarr(int *arr, intnum)
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 voidmain()
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)
", i*i, i, j*j, j, k*k, k, l*l, l);
63 }
64 }
65 }
66 }
67 }
68 
69     printf("共有%d种方法
", count);
70 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include<stdio.h>
4 #include<stdlib.h>
5 
6 main()
7 {
8     int a[3][4] = { 1,2,3,4,5,6,7,8,0,1,2,3};
9     inti, 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("");
19 }
20 
21     printf("以下是转置
");
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("");
31 }
32 
33     system("pause");
34 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include<stdio.h>
4 #include<stdlib.h>
5 
6 #define N 10
7 
8 main()
9 {
10     int a[N][N] = { 0};
11     inti, 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("");
28 }
29 
30     printf("输出等腰三角形
");
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("");
41 }
42 
43     system("pause");
44 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include<stdio.h>
4 #include<stdlib.h>
5 
6 void avg(int(*p)[4], int n)//用指向数组的指针存储二维数组名，传递多少个元素（一维数组）
7 {
8     inti, 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
", res);
21 }
22 
23 void show(int(*p)[4], intnum)
24 {
25     inti;
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     inti, 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("");
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     intnum;
64     avg(a, 3);
65 
66     //scanf("%d", &num);
67     //show(a, num);
68 
69 fail(a);
70 
71     system("pause");
72 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 
6 #define N 10
7 
8 voidmain()
9 {
10     int arr[N][N] = { 0 };//初始化数组
11     inti;
12     intj;
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("");
29 }
30 
31     system("pause");
32 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <time.h>
6 
7 #define N 10
8 
9 void zhizhen_myswap(int(*arr)[N], int n, int num1, int num2)//交换两行，第一个参数，数组名，第二个参数，列数，第三、四个参数，交换的两行。使用指针
10 {
11     inti;
12     inttemp;
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     inti;
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     inti;
37     intj;
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("");
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
");
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("");
73 }
74 
75 
76     system("pause");
77 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 
6 #define N 7
7 
8 main()
9 {
10     int a[N][N] = { 0 };//初始化数组
11     inti;
12     intj;
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("");
41 }
42 
43     system("pause");
44 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <math.h>
6 #include <time.h>
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     inti;
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     returnflag;
42 }
43 
44 voidmain()
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("");
62 }
63 
64     int *p = &arr[0][0];//指针，指向第一个元素的地址
65 
66     if (!jiou(*(p)) && isprime(*(p + 1)))//判断第一个元素，如果第一个元素是偶数，第二个元素是素数
67 {
68         sum += *(p);
69         printf("0,%d
", *(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
", 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
", i, *(p + M*N - 1));
96 }
97 
98     printf("sum=%d
", sum);
99 
100     system("pause");
101 }

1 #define _CRT_SECURE_NO_WARNINGS
2 
3 #include <stdio.h>
4 #include <stdlib.h>
5 
6 #define N 3//N可以为任何奇数，因为偶数矩阵没有对角线，故不符合题意
7 
8 voidmain() 
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("");
53 }
54 
55     system("pause");
56 }

1 #define _CRT_SECURE_NO_WARNINGS
2 #include <stdio.h>
3 
4 #define N 6
5 
6 voidmain()
7 {
8     int arr[N][N] = { 0};
9     inti;
10     intj;
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("");
40 }
41 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 
5 voidmain()
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     inti;
13     intj;
14     intk;
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("");
25 }
26 
27     printf("
");
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("");
37 }
38 
39     printf("
");
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("");
61 }
62 
63     system("pause");
64 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 
4 #define N 8
5 
6 voidmain()
7 {
8     int a[N][N] = { 0};
9 
10     inti;
11     intj;
12     intk;
13     intu;
14     intv;
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	", a[u][v]);
58 
59 }
60         printf("");
61 }
62 
63     system("pause");
64 }

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 
5 #define N 4
6 
7 voidmain()
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("");
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
", 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
", count, sum);
65 }
66 
67     system("pause");
68 }

1 #include <stdio.h>
2 #define N 7
3 
4 voidmain()
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("");
59 }
60 }

1 #include <stdio.h>
2 #include <time.h>
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     inttemp;
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     inti, 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("");
37 }
38 }
39 
40 voidmain()
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("二维数组排序，冒泡
");
58 
59     sort(arr, N, M);//二维数组排序，冒泡
60 
61     print(arr, N, M);//打印二维数组
62 }