學習目標
1.【掌握】數組的聲明數組
2.【掌握】數組元素的賦值和調用dom
3.【掌握】數組的初始化ide
4.【掌握】數組的遍歷函數
5.【掌握】數組在內存中的存儲學習
6.【掌握】數組長度計算spa
7.【掌握】數組的常見應用指針
8.【掌握】數組做爲函數的參數code
1、數組的聲明
做用：orm
能夠存儲指定數據類型指定個數的數據，數組與咱們以前學習的變量最大的不一樣就是咱們以前的變量只能存儲一個數據，而咱們的數組能夠存儲多個數據。blog
特色：
1.能夠存儲多個數據
2.雖然數組能夠存儲多個數據，可是並非什麼類型的數據均可以存儲的。要求存儲在數組中的數據的類型要一致，在建立數組的時候指定能夠存儲的多個數據的類型。
3.雖然數組能夠存儲多個數據，但不是任意個都能直接往裏面存儲的，數組之中能夠存儲的數據的個數是固定的，也是在建立數組的時候指定的，一旦指定，不能改變。
4.存儲在數組之中的數據很是方便管理，拿到數組就能夠很方便的拿到數組之中的數據
術語：
1.元素：數組中的每個小空間，就叫作數組的元素。
2.下標/索引：數組之中有不少元素，爲了區分每個元素，C語言就爲每個元素編了一個號，這個號就叫這個元素的下標/索引。下標/索引從0開始遞增。
3.長度：元素的個數。
語法：數組元素的數據類型 數組名[數組長度];
|
1
2
3
4
5
6
7
8
9
10
|
#include <stdio.h>
int
main
(
)
{
int
arr1
[
5
]
;
//能夠存儲5個int類型的數據
float
arr2
[
8
]
;
//能夠存儲8個float類型的數據
double
arr3
[
29
]
;
//能夠存儲29個double類型的數據
char
arr4
[
3
]
;
//能夠存儲3個char類型的數據
return
0
;
}
|
注意：
1.聲明數組的時候必需要指定數組的長度！
2.數組的長度能夠爲0，表示一個數據都不能存儲，數組長度也能夠爲1，表示只能存儲一個數據，但長度不能給負數和小數。
3.數組長度能夠是常量，變量，宏，表達式。可是長度一旦聲明，長度就不能改了。
4.當數組長度爲變量的時候，是不能在聲明數組的同時爲數組元素初始化值的。只能先聲明數組，而後再爲元素賦值。
2、數組元素的賦值和調用
數組真正用來存儲數據的是數組中的元素，而不是數組自己，數組指的是整個數組，因此咱們不能直接爲數組賦值。因此咱們應該將數據賦值給數組中的元素。數組之中有多個元素，元素的本質其實就是一個普通類型的變量。那咱們如何肯定是爲哪一個元素賦值呢？
賦值語法：數組名[元素的下標] = 數據;
|
1
2
3
4
5
|
int
arr
[
3
]
;
//聲明一個int類型的數組
arr
=
10
;
//錯誤,不能直接爲數組賦值
arr
[
0
]
=
10
;
//正確,爲數組第一個元素賦值1
arr
[
0
]
=
11
;
//正確,元素本質就是普通變量,能夠重複賦值
arr
[
3
]
=
10
;
//錯誤,元素個數是3,但下標最大才2.數組下標不能越界
|
調用語法：數組名[元素下標];
|
1
2
3
4
|
int
arr
[
3
]
;
//聲明一個int類型的數組
arr
[
0
]
=
10
;
//爲元素賦值
int
num
=
arr
[
0
]
;
//將第一個元素的值取出賦值給int類型的變量num
int
num1
=
arr
[
3
]
;
//下標越界,取不到想要的值
|
3、數組的初始化
在聲明數組的同時就初始化數組之中的每個元素的值。
|
1
2
3
4
5
|
int
arr
[
3
]
=
{
1
,
2
,
3
}
;
//注意不要越界
int
arr1
[
]
=
{
1
,
2
,
3
}
;
//若是沒有指定元素個數,初始化的時候,後面有多少個數據,C語言就自動肯定數組個數
int
arr2
[
3
]
=
{
1
}
;
//部分初始化.將第一個元素初始化爲1,其餘元素初始化爲0
int
arr3
[
3
]
=
{
1
,
2
}
;
//部分初始化,依次從第一個元素初始化,不夠的元素初始化爲0
int
arr4
[
3
]
=
{
[
1
]
=
100
}
;
//指定下標初始化,其餘元素初始化爲0
|
注意：
在聲明數組的時候初始化元素，若是元素個數使用變量，就不能初始化。在編譯的時候，編譯器是不知道數組的長度的，因此無法初始化。
|
1
2
3
4
5
|
int
main
(
)
{
int
length
=
4
;
int
arr
[
length
]
;
//不初始化就不會報錯
//int arr1[length] = {1,2,3}; 這樣就不行，會報錯
}
|
4、數組的遍歷
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
int
main
(
)
{
//聲明數組併爲每一個元素賦值
int
arr
[
3
]
;
arr
[
0
]
=
1
;
arr
[
1
]
=
2
;
arr
[
2
]
=
3
;
//將每個元素的下標遍歷出來，當作數組的下標就能遍歷數組了
//下標 == 數組長度-1
for
(
int
i
=
0
;
i
<
3
;
i
++
)
{
printf
(
"%d\n"
,
arr
[
i
]
)
;
}
return
0
;
}
|
5、數組在內存中的存儲
數組其實就是由指定個數的連續的變量組合成的，存儲方式和普通變量存儲方式相同，把每個元素當作一個普通變量。分配內存空間的時候，只是分配多個連續空間分別存儲每一個元素，並且也是從高地址向低地址連續分配的。每一個元素的地址，就是他佔用字節的最低字節的地址。
|
1
2
3
4
|
int
arr
[
3
]
;
arr
[
0
]
;
//低地址，數組的地址就是第一個元素的地址
arr
[
1
]
;
arr
[
2
]
;
//高地址
|
數組的地址：數組之中第1個元素的地址，就是數組的地址。也就是下標爲0的元素的地址。
6、數組長度計算
sizeof(數組名)計算出這個數組在內存中佔用的總字節數。
sizeof(數據類型)計算出每一個元素在內存中佔用的字節數。
元素個數 = sizeof(數組名)/sizeof(數據類型);
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#include <stdio.h>
int
main
(
)
{
int
scores
[
5
]
=
{
0
}
;
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//元素個數 = 數組總字節 / 每一個元素字節;
//講用戶輸入數據存儲到數組
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
printf
(
"請輸入第%d個同窗的年齡:"
,
i
+
1
)
;
scanf
(
"%d"
,
&
scores
[
i
]
)
;
}
//遍歷打印出數組
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
printf
(
"scores[%d] = %d\n"
,
i
,
scores
[
i
]
)
;
}
return
0
;
}
|
7、數組的常見應用
1.求最大值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//假設第一個元素爲最大值
int
max
=
scores
[
0
]
;
for
(
int
i
=
1
;
i
<
length
;
i
++
)
{
//將max和每一個元素相比,大的就賦值給max
if
(
max
<
scores
[
i
]
)
{
max
=
scores
[
i
]
;
}
}
printf
(
"max = %d\n"
,
max
)
;
return
0
;
}
|
2.求最小值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//假設第一個元素爲最小值
int
min
=
scores
[
0
]
;
for
(
int
i
=
1
;
i
<
length
;
i
++
)
{
//將max和每一個元素相比,小的就賦值給max
if
(
min
>
scores
[
i
]
)
{
min
=
scores
[
i
]
;
}
}
printf
(
"min = %d\n"
,
min
)
;
return
0
;
}
|
3.求累加和
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//sum存儲累加和
int
sum
=
0
;
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
sum
+=
scores
[
i
]
;
}
printf
(
"sum = %d\n"
,
sum
)
;
return
0
;
}
|
4.求平均值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//sum存儲累加和
int
sum
=
0
;
//平均值
float
avg
=
0
;
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
sum
+=
scores
[
i
]
;
}
avg
=
(
float
)
sum
/
length
;
printf
(
"avg = %.2f\n"
,
avg
)
;
return
0
;
}
|
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
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//須要找的數
int
zhaoNum
=
879
;
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
if
(
scores
[
i
]
==
zhaoNum
)
{
printf
(
"找到了\n"
)
;
break
;
}
if
(
i
==
length
-
1
)
{
printf
(
"沒找到\n"
)
;
}
}
return
0
;
}
|
6.查找指定元素在數組中第一次出現的下標
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#include <stdio.h>
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
4
,
657
,
684
,
5322
,
64765
,
8799
,
45453
,
34232
,
345
}
;
//計算數組長度
int
length
=
sizeof
(
scores
)
/
sizeof
(
int
)
;
//須要找的數
int
zhaoNum
=
325
;
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
if
(
scores
[
i
]
==
zhaoNum
)
{
printf
(
"下標爲:%d"
,
i
)
;
break
;
}
if
(
i
==
length
-
1
)
{
printf
(
"沒找到\n"
)
;
}
}
return
0
;
}
|
7.選擇排序
|
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
|
#include <stdio.h>
void
selectSort
(
int
arr
[
]
,
int
length
)
{
//外層控制比較的輪數
for
(
int
i
=
0
;
i
<
length
-
1
;
i
++
)
{
//內層控制每輪比較的次數
for
(
int
j
=
i
+
1
;
j
<
length
;
j
++
)
{
//當每輪循環的第一個元素小於後面的元素時
if
(
arr
[
i
]
<
arr
[
j
]
)
{
//就交換他們的位置
arr
[
i
]
=
arr
[
i
]
^
arr
[
j
]
;
arr
[
j
]
=
arr
[
i
]
^
arr
[
j
]
;
arr
[
i
]
=
arr
[
i
]
^
arr
[
j
]
;
}
}
}
}
int
main
(
)
{
int
arr
[
]
=
{
1
,
3423
,
54
,
646
,
4
,
2
,
3423
,
4
,
656
,
34
,
34
,
36
,
4
,
24
,
}
;
//計算數組長度
int
length
=
sizeof
(
arr
)
/
sizeof
(
int
)
;
//調用函數對數組進行排序
selectSort
(
arr
,
length
)
;
//遍歷打印出排序後的數組
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
printf
(
"%d "
,
arr
[
i
]
)
;
}
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
|
#include <stdio.h>
#include <stdlib.h>
int
cha
(
int
arr
[
]
,
int
length
,
int
zhaoNum
)
{
//遍歷數組
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
//判斷數組中有沒有要查找的數據
if
(
arr
[
i
]
==
zhaoNum
)
{
//有則返回1
return
1
;
}
if
(
i
==
length
-
1
)
{
return
0
;
}
}
return
0
;
}
int
main
(
)
{
int
arr
[
6
]
=
{
0
}
;
int
length
=
sizeof
(
arr
)
/
sizeof
(
int
)
;
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
//隨機生成1-33的整數
int
num
=
arc4random_uniform
(
33
)
+
1
;
//調用函數判斷數組中是否存在,返回0則不存在
if
(
cha
(
arr
,
length
,
num
)
==
0
)
{
//不存在就存進數組
arr
[
i
]
=
num
;
}
else
{
//存在就從新生成
i
--
;
}
}
//打印出隨機生成的6個紅球
for
(
int
i
=
0
;
i
<
length
;
i
++
)
{
printf
(
"%d "
,
arr
[
i
]
)
;
}
return
0
;
}
|
8、數組做爲函數的參數
若是函數的形參是一個數組，在調用這個函數的時候，也必需要爲這個函數傳入一個相同類型的數組，而且是傳入數組的地址。而後函數操做的就是咱們傳進去那個數組，改變數組中的元素，也就是改變傳入的那個數組的元素。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#include <stdio.h>
void
test
(
int
num
[
]
)
{
num
[
0
]
=
10
;
}
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
44232
,
345
}
;
//調用函數,傳入數組名,數組名就是數組的地址
test
(
scores
)
;
printf
(
"%d\n"
,
scores
[
0
]
)
;
//打印 10
return
0
;
}
|
注意：當數組做爲函數的參數的時候，傳入的是數組的地址，一個地址佔據8個字節。但一個數組若是佔據的內存大於8字節，將不能在函數裏經過sizeof計算數組的長度。並且函數裏的形參是去內存中申請8個字節存儲指針變量，並將傳入的數組地址賦值給這個指針變量。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#include <stdio.h>
void
test
(
int
num
[
]
)
{
printf
(
"%p\n"
,
num
)
;
}
int
main
(
)
{
//隨便整一個int類型的數組
int
scores
[
]
=
{
232
,
545
,
23
,
325
,
44232
,
345
}
;
//調用函數,傳入數組
test
(
scores
)
;
printf
(
"%p\n"
,
scores
)
;
return
0
;
}
|
咱們會發現函數中打印的數組地址和咱們聲明的數組的地址是一致的