===========================
2022-7-25
===========================
一.温故知新
数组
线性的存储
线性表
顺序表
数组
一维数组
1.数组
1)数组的含义
数组就是用来存储一组相同类型的数据
2)数组的定义
数据类型 数组名[成员个数];
int arr [10] ;
定义了10个int类型成员的数组
arr[0] - arr[9]
3)访问数组的成员
数组名 + 下标 arr[3];
数组名 + 偏移量 *(arr+3);
指针 + 偏移量 *(p + 3);
指针 + 下标 p[3];
4)数组的特性
sizeof(数组名) = 整个数组的大小
sizeof(成员) = 一个成员的大小
sizeof(数组名) / sizeof(成员) = 成员个数
打印地址
数组的成员占用了连续的存储空间
一维数组的数组名相当于是数组首成员的地址
C语言的第一阶段过渡到第二阶段
多维数组
二维数组
二维数组
链表
有头/无头(头节点<无实质数据>)
循环/不循环
单向/双向
两种特殊的存储形式
栈式存储结构 先进后出
队列式存储结构 先进先出
小项目:五子棋
1.player VS player
要求
1>最少完成p v p版本
2>用多函数实现
3>完成五子棋最基本功能即可
4>要有适当的提示信息
5>代码中要有注释
6>以组为单位交付
提示
1>棋盘存储
2>坐标的打印
3>玩家的替换
4>下到重复位置/下出边界以后的处理
5>判断赢的条件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void draw(int arr[15][15])
{
int i = 0, j = 0;
printf(" 1 2 3 4 5 6 7 8 9 A B C D E F\n");
for(i = 0; i < 15; i++)
{
printf("%X ", i + 1);
for(j = 0; j < 15; j++)
{
switch(arr[i][j])
{
case 0 : printf("+ "); break;
case 1 : printf("O "); break;
case 2 : printf("X "); break;
}
}
printf("\n");
}
}
int main(int argc, char *argv[])
{
//二维数组中 成员=0 该处无棋子
//成员=1 玩家1下棋
//成员=2 玩家2下棋
int arr[15][15] = {0};//定义二维数组初始化成0
int x = 0, y = 0;//下棋子的坐标
int flag = 1;//标记玩家
do
{
draw(arr);//通过draw函数画棋盘
printf("Player %d > ", flag);
scanf("%d-%d", &x, &y);
//做判断x 和 y的位置是否合理
arr[x - 1][y - 1] = flag;
flag ^= 3;
}while(win());
return 0;
}
多维数组和二维数组的关系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
int main(int argc, char *argv[])
{
int arr[7][4][4][4] = {
{
{
{0,0,0,0},
{0,0,0,0},
{0,0,0,0},
{1,1,1,1}
},
{
{0,0,0,1},
{0,0,0,1},
{0,0,0,1},
{0,0,0,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,0,0,0},
{1,1,1,1}
},
{
{0,0,0,1},
{0,0,0,1},
{0,0,0,1},
{0,0,0,1}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,1,0,0},
{0,1,1,1}
},
{
{0,0,0,0},
{0,0,1,1},
{0,0,1,0},
{0,0,1,0}
},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,1},
{0,0,0,1}
},
{
{0,0,0,0},
{0,0,0,1},
{0,0,0,1},
{0,0,1,1}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,0},
{0,1,1,1}
},
{
{0,0,0,0},
{0,0,1,0},
{0,0,1,1},
{0,0,1,0}
},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,1},
{0,0,1,0}
},
{
{0,0,0,0},
{0,0,0,1},
{0,0,1,1},
{0,0,0,1}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,0,0,1},
{0,1,1,1}
},
{
{0,0,0,0},
{0,0,1,0},
{0,0,1,0},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,1},
{0,1,0,0}
},
{
{0,0,0,0},
{0,0,1,1},
{0,0,0,1},
{0,0,0,1}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,0},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,1},
{0,0,1,1},
{0,0,1,0}
},
{
{0,0,0,0},
{0,0,0,0},
{0,1,1,0},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,1},
{0,0,1,1},
{0,0,1,0}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,0,1,1}
}
},
{
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,1,1,0}
},
{
{0,0,0,0},
{0,0,1,0},
{0,0,1,1},
{0,0,0,1}
},
{
{0,0,0,0},
{0,0,0,0},
{0,0,1,1},
{0,1,1,0}
},
{
{0,0,0,0},
{0,0,1,0},
{0,0,1,1},
{0,0,0,1}
}
}
};
int i = 0, j = 0, x = 0, y = 0;
srand(getpid());
while(1)
{
x = rand() % 7;
y = rand() % 4;
system("clear");
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
if(arr[x][y][i][j] == 1)
printf("[]");
else
printf(" ");
}
printf("\n");
}
sleep(1);
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 二维数组
1.二维数组的含义
是用来存储相同类型的数据的
可以抽象出行和列的存储形式,适合存储矩阵的数据
2.二维数组的定义
数据类型 数组名 [行数] [列数] ;
char arr [2] [3] ;
int arr [3] [4] ;
float arr [4] [2] ;
无论是行数还是列数都是从0开始计数的
arr[0][0] arr[0][1] arr[0][2] arr[0][3]
arr[1][0] arr[1][1] arr[1][2] arr[1][3]
arr[2][0] arr[2][1] arr[2][2] arr[2][3]
3.访问二维数组成员的方法
1)数组名 + 下标
2)数组名 + 偏移量
二级指针不能和二维数组产生关联(类型不匹配)
需要使用数组指针和二维数组产生关联
4.二维数组的特性
1)通过sizeof运算符进行测试
int arr[2][3];
sizeof(arr) = 24 = 整个数组的大小
sizeof(arr[0]) = 12 = 一行的大小
sizeof(arr[0][0]) = 4 = 一个成员的大小
sizeof(arr) / sizeof(arr[0][0]) = 6 = 成员个数
sizeof(arr) / sizeof(arr[0]) = 2 = 行数
sizeof(arr[0] / sizeof(arr[0][0])) = 3 = 列数
2)虽然二维数组可以抽象出行和列的形式,
但是二维数组中的每个成员的地址都是连续的
3)二维数组的数组名表示的数组首行的地址
5.二维数组的初始化
数据类型 数组名 [行数][列数] = {数值,数值};
int arr[2][3] = {0};//所有成员都初始化为0
int arr[2][3] = {11,22,33,44,55,66};
//每个成员获取一个数值
int arr[2][3] = {{11,22,33},{44,55,66}};
===============================================
int arr[][3] = {11,22,33,44,55,66};
注意 : 二维数组特殊的初始化方式,可以不指定行数
但是列数必须要指定
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
void print(int arr[2][3]);
void change(int arr[][3]);
void print(int arr[2][3])
{
int i = 0, j = 0;
//for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
for(i = 0; i < 2; i++)
{
for(j = 0; j < 3; j++)
{
printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
}
}
}
void change(int arr[][3])
{
int i = 0, j = 0;
for(i = 0; i < 2; i++)
{
for(j = 0; j < 3; j++)
{
scanf("%d", &arr[i][j]);
}
}
}
int main(int argc, char *argv[])
{
int arr[2][3] = {11,22,33,44,55,66};
print(arr);//通过print函数遍历二维数组
change(arr);//通过change函数改变二维数组的数据
print(arr);//通过print函数遍历二维数组
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
int main(int argc, char *argv[])
{
int i = 0, j = 0;
int num = 1;
int arr[3][4];
int **pp = arr;
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
arr[i][j] = num++;
}
}
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
}
}
return 0;
}
int main(int argc, char *argv[])
{
int i = 0, j = 0;
int num = 1;
int arr[3][4];
int **pp = arr;
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
arr[i][j] = num++;
}
}
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
}
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int main(int argc, char *argv[])
{
int i = 0, j = 0;
int num = 1;
int arr[3][4];
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
arr[i][j] = num++;
}
}
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
}
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int main(int argc, char *argv[])
{
int arr[3][4];
printf("&arr[0][0] = %p\n", &arr[0][0]);
//表示的是数组首成员的地址
printf("&arr[0] = %p\n", &arr[0]);
//表示的是数组首行的地址
printf("arr[0] = %p\n", arr[0]);
//表示的是数组首成员的地址
printf("arr = %p\n", arr);
//表示的是数组首行的地址
printf("&arr = %p\n", &arr);
//表示的是整个数组的地址
printf("*arr = %p\n", *arr);
printf("========================\n");
printf("&arr[0][0] + 1 = %p\n", &arr[0][0] + 1);
printf("&arr[0] + 1 = %p\n", &arr[0] + 1);
printf("arr[0] + 1 = %p\n", arr[0] + 1);
printf("arr + 1 = %p\n", arr + 1);
printf("&arr + 1 = %p\n", &arr + 1);
printf("*arr + 1 = %p\n", *arr + 1);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int main(int argc, char *argv[])
{
int arr[3][4];
int i = 0, j = 0;
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
printf("&arr[%d][%d] = %p\n", i,j,&arr[i][j]);
}
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(int argc, char *argv[])
{
int arr[3][4];
printf("sizeof(arr[0][0]) = %ld\n",sizeof(arr[0][0]));
printf("sizeof(arr[0]) = %ld\n",sizeof(arr[0]));
printf("sizeof(arr) = %ld\n",sizeof(arr));
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main(int argc, char *argv[])
{
int i = 0, j = 0;
int num = 1;
int arr[3][4];
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
arr[i][j] = num++;
}
}
for(i = 0; i < 3; i++)
{
for(j = 0; j < 4; j++)
{
printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
}
}
return 0;
}
输入十个人的身高,要求排序,从低到高打印
排序 (选择法排序)
首先从未排序的成员中找到最值
然后和数组开头的成员进行交换
然后再从剩余的未排序的成员中找到最值
然后再和剩余成员的开头位置进行交换
以此类推
=============================
把冒泡法排序和选择法排序给组长讲一遍
(以讲懂了为标准)
=============================
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
void print(const int *arr, int size);
void sort(int *arr, int size);
void print(const int *arr, int size)
{
int i = 0;
for(i = 0; i < size; i++)
printf("%d\t", arr[i]);
printf("\n");
getchar();
}
void sort(int *arr, int size)
{
int i = 0, j = 0, k = 0;
int tmp = 0;
for(i = 0; i < size - 1; i++)
{
k = i;//让k和i标记相同的位置
for(j = i + 1; j < size; j++)
{
if(arr[k] > arr[j])
k = j;//让k标记j的位置
}
if(i != k)//判断i和k是否标记相同的位置
{
tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
print(arr, size);
}
}
}
int main(int argc, char *argv[])
{
int arr[5] = {100, 201, 50, 70, 30};
int size = sizeof(arr) / sizeof(*arr);
print(arr, size);//通过print函数遍历数组
sort(arr, size);//通过sort函数进行从小到大的排序
print(arr, size);//通过print函数遍历数组
return 0;
}
输入十个人的身高,要求排序,从低到高打印
排序 (冒泡法排序)
比较两个相邻的成员,如果不满足大小顺序,当即完成交换操作
按照遍历顺序把第一对相邻的成员到
最后一对相邻的成员都完成对比
这样数组中的最值就冒到了最后的位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
void print(const int *arr, int size);
void sort(int *arr, int size);
void print(const int *arr, int size)
{
int i = 0;
for(i = 0; i < size; i++)
printf("%d\t", arr[i]);
printf("\n");
getchar();
}
void sort(int *arr, int size)
{
int i = 0, j = 0;
int tmp = 0;
for(i = 0; i < size - 1; i++)
{
for(j = 0; j < size - 1 - i; j++)
{
if(arr[j] > arr[j + 1])
{
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
print(arr, size);
}
}
}
}
int main(int argc, char *argv[])
{
int arr[5] = {100, 201, 50, 70, 30};
int size = sizeof(arr) / sizeof(*arr);
print(arr, size);//通过print函数遍历数组
sort(arr, size);//通过sort函数进行从小到大的排序
print(arr, size);//通过print函数遍历数组
return 0;
}
有1000发子弹,要提前装到10个箱子里面，接收键盘输入，要取多少颗子弹数，只能显示整箱的个数，问这10个箱子怎么装,编程实现
二进制 100
逐次趋近式的方法
arr[0] = 1
arr[1] = 2
arr[2] = 4
arr[3] = 8
arr[4] = 16
arr[5] = 32
arr[6] = 64
arr[7] = 128
arr[8] = 256
arr[9] = 489
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
void init(int *, int);
void print(int *, int);
void take_out(int , int *, int);
void init(int *arr, int size)
{
int i = 0;
int sum = 1;
int x = 0;
for(i = 0; i < size - 1; i++)
{
arr[i] = sum;
x += sum;
sum *= 2;
}
arr[i] = 1000 - x;
}
void print(int *arr, int size)
{
int i = 0;
for(i = 0; i < size; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void take_out(int num, int *arr, int size)
{
int i = 0;
for(i = size - 1; i >= 0; i--)
{
if(arr[i] <= num)
{
printf("arr[%d] = %d\n", i, arr[i]);
num -= arr[i];
}
}
}
int main(int argc, char *argv[])
{
int arr[10] = {0};//存子弹
int size = sizeof(arr) / sizeof(arr[0]);//存储成员个数
int num = 0;//存储要取走的子弹数
init(arr, size);//通过init函数存储子弹
print(arr, size);//通过print函数遍历数组
scanf("%d", &num);//录入取走的子弹数
take_out(num, arr, size);//取子弹
return 0;
}
进制转换的计算器
完成itob函数(十->八)
十 -> 二
void itob(int num, int arr[8], int size);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
void itob(int num, int *arr, int size);
void print(int *arr, int size);
void itob(int num, int *arr, int size)
{
int i = 0;
for(i = size - 1; i >= 0; i--)
{
arr[i] = num % 2;
num /= 2;
}
}
void print(int *arr, int size)
{
int i = 0;
for(i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main(int argc, char *argv[])
{
int num = 0;//保存录入的十进制数字
int arr[32] = {0};//初始化8个成员的数组
int size = sizeof(arr) / sizeof(*arr);//保存成员个数
scanf("%d", &num);//录入十进制数字
itob(num, arr, size);//调用itob把十进制转换成二进制
print(arr, size);//通过print函数遍历数组
return 0;
}
口算卡
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
void Rand(int *, int *, int *);
int print(int , int , int);
int cmp(int , int);
void Rand(int *s1, int *s2, int *c)
{
*s1 = rand() %10;
*s2 = rand() % 9 + 1;
*c = rand() % 5;
}
int print(int s1, int s2, int c)
{
switch(c)
{
case 0:printf("%d + %d = ", s1, s2);return s1+s2;
case 1:printf("%d - %d = ", s1, s2);return s1-s2;
case 2:printf("%d * %d = ", s1, s2);return s1*s2;
case 3:printf("%d / %d = ", s1, s2);return s1/s2;
case 4:printf("%d %% %d = ", s1, s2);return s1%s2;
}
}
int cmp(int T, int guess)
{
if(T == guess)
{
printf("Bingo! +10分!\n");
return 10;
}
else
{
printf("Error! === %d\n", T);
return 0;
}
}
int main(int argc, char *argv[])
{
int s1 = 0, s2 = 0, c = 0;//2个操作数以及1个运算符
int T = 0, guess = 0;//1个正确结果和一个客户填写的答案
int score = 0;//记录总分
int i = 0;
srand(getpid());//随机种子
for(i = 0; i < 10; i++)
{
Rand(&s1, &s2, &c);//产生随机数
T = print(s1, s2, c);//打印表达式并把正确结果返回
scanf("%d", &guess);//录入正确的结果
score += cmp(T, guess);//对比结果
}
printf("总分 : %d\n", score);
return 0;
}