PowerPoint Presentation

Transcription

1 Chapter 6 Arrays ( 陣列 ) 1 Outline 6.1 Introduction 6.2 Arrays 6.3 Declaring Arrays 6.4 Examples Using Arrays 6.5 Passing Arrays to Functions 6.6 Sorting Arrays 6.7 Case Study: Computing Mean, Median and Mode Using Arrays 6.8 Searching Arrays 6.9 Multiple-Subscripted Arrays

2 2 Objectives In this chapter, you will learn: To introduce the array data structure. To understand the use of arrays to store, sort and search lists and tables of values. To understand how to define an array, initialize an array and refer to individual elements of an array. To be able to pass arrays to functions. To understand basic sorting techniques. To be able to define and manipulate multiple subscript arrays.

3 3 6.1 Introduction Arrays Structures of related data items Static entity same size throughout program Dynamic data structures discussed in Chapter 12

4 4 6.2 Arrays Array Group of consecutive memory locations Same name and type To refer to an array element, need to specify Array name ( 陣列名稱 ) Position number ( 位置編號 ), or the subscript Format: arrayname[ position number ] First element at position 0 ( 編號從 0 開始 ) n element array named c: c[ 0 ], c[ 1 ]...c[ n 1 ]

5 5 6.2 Arrays Array elements are like normal variables c[ 0 ] = 3; printf( "%d", c[ 0 ] ); Can perform operations in subscript. If x equals 3, then c[ 5-2 ], c[ 3 ] and c[ x ] are the same If a = 5 and b = 6, then the statement c[ a + b ] += 2; adds 2 to array element c[ 11 ].

6 6 6.2 Arrays Operators Associativity Type [] () left to right highest ++ --! (type) right to left unary * / % left to right multiplicative + - left to right additive < <= > >= left to right relational ==!= left to right equality && left to right logical and left to right logical or?: right to left conditional = += -= *= /= %= right to left assignment, left to right comma Fig. 6.2 Operator precedence.

7 7 6.3 Defining Arrays When defining arrays, specify Name Type of array Number of elements arraytype arrayname[ numberofelements ]; Examples: int c[ 10 ]; float myarray[ 3284 ]; Defining multiple arrays of same type Format similar to regular variables Example: int b[ 100 ], x[ 27 ];

8 Initializers int n[ 5 ] = { 1, 2, 3, 4, 5 }; 8 If not enough initializers, rightmost elements become 0 int n[ 5 ] = { 0 };/* { 0, 0, 0, 0, 0 } */ int n[ 5 ] = { 1 };/* { 1, 0, 0, 0, 0 } */ If too many, a syntax error is produced int n[ 5 ] = { 1, 2, 3, 4, 5, 6 }; /*error!*/ C arrays have no bounds checking If size omitted, initializers determine it int n[ ] = { 1, 2, 3, 4, 5 }; 5 initializers, therefore 5 element array

9 1 /* Fig. 6.3: fig06_03.c 2 initializing an array */ 3 #include <stdio.h> 4 Defining an Array and Using a Loop to Initialize the Array's Elements 5 /* function main begins program execution */ 6 int main() 7 { 8 int n[ 10 ]; /* n is an array of 10 integers */ 9 int i; /* counter */ /* initialize elements of array n to 0 */ 12 for ( i = 0; i < 10; i++ ) { 13 n[ i ] = 0; /* set element at location i to 0 */ 14 } /* end for */ printf( "%s%13s\n", "Element", "Value" ); /* output contents of array n in tabular format */ 19 for ( i = 0; i < 10; i++ ) { 20 printf( "%7d%13d\n", i, n[ i ] ); 21 } /* end for */ return 0; /* indicates successful termination */ } /* Copyright end main by Deitel */ 宣告含十個元素的整數陣列 fig06_03.c 若改為 for ( i = 0 ; i <= 10; i++ ) 會如何? 此處 Element 與 Value 為兩個字串, 在 printf 中利用 %s 把字串輸出到螢幕 ; 注意第二個 %13s 中 13 表示給 13 個空位列印 Value 字串 9

10 Element Value Program Output 10

11 11 若改為 for ( i = 0 ; i <= 10; i++ ) 會如何? Caution: C 語言並不檢查索引值的大小 (No array bounds checking in C! ), 也就使說當索引值超過陣列長度時, 在編譯時不會發生錯誤, 但在執行程式時, 就會發生不可預期的錯誤, 而且這種錯誤有時並不容易檢查出來

12 12 Caution: C 語言並不檢查索引值的大小 (No array bounds checking in C! ), 也就使說當索引值超過陣列長度時, 在編譯時不會發生錯誤, 但在執行程式時, 就會發生不可預期的錯誤, 而且這種錯誤有時並不容易檢查出來

13 Initializing an Array in a Definition with an Initializer List 13 1 /* Fig. 6.4: fig06_04.c 2 Initializing an array with an initializer list */ 3 #include <stdio.h> 4 5 /* function main begins program execution */ 6 int main() 7 { 8 /* use initializer list to initialize array n */ 9 int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 }; 10 int i; /* counter */ printf( "%s%13s\n", "Element", "Value" ); /* output contents of array in tabular format */ 15 for ( i = 0; i < 10; i++ ) { 16 printf( "%7d%13d\n", i, n[ i ] ); 17 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_04.c 宣告含十個元素整數陣列, 同時設定各元素的值

14 Element Value Program Output 14

15 Specifying an Array's Size with a Symbolic Constant and Initializing Array Elements with Calculations 1 /* Fig. 6.5: fig06_05.c 2 Initialize the elements of array s to the even integers from 2 to 20 */ 3 #include <stdio.h> 4 #define SIZE /* function main begins program execution */ 7 int main() 8 { 9 /* symbolic constant SIZE can be used to specify array size */ 10 int s[ SIZE ]; /* array s has 10 elements */ 11 int j; /* counter */ for ( j = 0; j < SIZE; j++ ) { /* set the values */ 14 s[ j ] = * j; 15 } /* end for */ printf( "%s%13s\n", "Element", "Value" ); /* output contents of array s in tabular format */ 20 for ( j = 0; j < SIZE; j++ ) { 21 printf( "%7d%13d\n", j, s[ j ] ); 22 } /* end for */ return 0; /* indicates successful termination */ } /* Copyright end main by */ Deitel #define SIZE 10 # 前置處理器指令 (preprocessor directive) fig06_05.c Define a symbolic constant ( 符號常數 ) SIZE whose value is 10 Symbolic constant SIZE in the code is replaced by text 10 before compilation Makes programs more scalable ( 將來如果要調整陣列的大小, 只需重設 SIZE 的值即可 ) 習慣上 symbolic constant names 使用大寫字母 下面兩種是錯誤的寫法 ( 不可加 分號 ; 及 等號 = ) #define SIZE = 10 #define SIZE 10; 15

16 Element Value Program Output 16

17 Summing the Elements of an Array 17 1 /* Fig. 6.6: fig06_06.c 2 Compute the sum of the elements of the array */ 3 #include <stdio.h> 4 #define SIZE /* function main begins program execution */ 7 int main() 8 { 9 /* use initializer list to initialize array */ 10 int a[ SIZE ] = { 1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45 }; 11 int i; /* counter */ 12 int total = 0; /* sum of array */ /* sum contents of array a */ 15 for ( i = 0; i < SIZE; i++ ) { 16 total += a[ i ]; 17 } /* end for */ printf( "Total of array element values is %d\n", total ); return 0; /* indicates successful termination */ } /* end main */ Total of array element values is 383 fig06_06.c 在此計算各元素之和 ; total = total + a [ i ];

18 1 /* Fig. 6.7: fig06_07.c 2 Student poll program */ 3 #include <stdio.h> 4 #define RESPONSE_SIZE 40 /* define array sizes */ 5 #define FREQUENCY_SIZE /* function main begins program execution */ 8 int main() 9 { 10 int answer; /* counter */ 11 int rating; /* counter */ /* initialize frequency counters to 0 */ 14 int frequency[ FREQUENCY_SIZE ] = { 0 }; /* place survey responses in array responses */ 17 int responses[ RESPONSE_SIZE ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 18 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6, 19 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 }; 20 Using Arrays to Summarize Survey Results Forty students were asked to rate the quality of the food in the student cafeteria on a scale of 1 to 10. Place the 40 responses in an integer array and summarize the results of the poll. 本範例中有兩個分別為 responses 及 frequency 的陣列 ; responses 為個別學生所打的分數所組成的陣列 ;frequency 則為出現某分數之次數所組成的 例如 frequency[ 1 ] 為將分數打為 1 的學生人數 ( 次數 ) 由於共有 10 種分數, 故將 frequency 的陣列定為 11 ; 如此就有 frequency[ 1 ] frequency[ 2 ]... frequency[ 9 ] frequency[ 10 ] 十種分數的個別次數 在這裡 frequency[0] 並未使用 fig06_07.c (Part 1 of 2) 18

19 21 /* for each answer, select value of an element of array responses 22 and use that value as subscript in array frequency to 23 determine element to increment */ 24 for ( answer = 0; answer < RESPONSE_SIZE; answer++ ) { 25 ++frequency[ responses [ answer ] ]; 26 } /* end for */ /* display results */ 29 printf( "%s%17s\n", "Rating", "Frequency" ); /* output frequencies in tabular format */ 32 for ( rating = 1; rating < FREQUENCY_SIZE; rating++ ) { 33 printf( "%6d%17d\n", rating, frequency[ rating ] ); 34 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_07.c (Part 2 of 2) Key Statement: ++frequency[ responses[ answer ] ]; 19 Rating Frequency Caution: C 語言並不檢查索引值的大小 (No array bounds checking in C! ), 也就使說當索引值超過陣列長度時, 在編譯時不會發生錯誤, 但在執行程式時, 就會發生不可預期的錯誤, 而且這種錯誤有時並不容易檢查出來 What if responses[23] = 13?

20 Graphing Array Element Values with Histograms 1 /* Fig. 6.8: fig06_08.c 2 Histogram printing program */ 3 #include <stdio.h> 4 #define SIZE /* function main begins program execution */ 7 int main() 8 { 9 /* use initializer list to initialize array n */ 10 int n[ SIZE ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; 11 int i; /* outer counter */ 12 int j; /* inner counter */ printf( "%s%13s%17s\n", "Element", "Value", "Histogram" ); /* for each element of array n, output a bar in histogram */ 17 for ( i = 0; i < SIZE; i++ ) { 18 printf( "%7d%13d ", i, n[ i ]) ; for ( j = 1; j <= n[ i ]; j++ ) { /* print one bar */ 21 printf( "%c", '*' ); 22 } /* end inner for */ 23 Reads numbers from an array and graphs the information in the form of a bar chart or histogram 8 spaces fig06_08.c (Part 1 of 2) 印一顆星星用 printf( "%c", '*' ); 例如要印出 3 7 ******* n[3] 星星數 就可用此段迴圈 20

21 24 printf( "\n" ); /* start next line of output */ 25 } /* end outer for */ return 0; /* indicates successful termination */ } /* end main */ Element Value Histogram 0 19 ******************* 1 3 *** 2 15 *************** 3 7 ******* 4 11 *********** 5 9 ********* 6 13 ************* 7 5 ***** 8 17 ***************** 9 1 * fig06_08.c (Part 2 of 2) Program Output 21

22 Rolling a Die 6000 Times and Summarizing the Results in an Array (in Chapter 5) /* determine face value and increment appropriate counter */ 24 switch ( face ) { case 1: /* rolled 1 */ 27 ++frequency1; 28 break; case 2: /* rolled 2 */ 31 ++frequency2; 32 break; case 3: /* rolled 3 */ 35 ++frequency3; 36 break; case 4: /* rolled 4 */ 39 ++frequency4; 40 break; case 5: /* rolled 5 */ 43 ++frequency5; 44 break; case 6: /* rolled 6 */ 47 ++frequency6; 48 break; 49 } /* end switch */ Recall that in Chapter 5 (Fig. 5.8): 擲骰子後, 每一個點數就有一個出現的次數 : Six Variables: frequency1 frequency2 frequency3 frequency4 frequency5 frequency6

23 Rolling a Die 6000 Times and Summarizing the Results in an Array 23 1 /* Fig. 6.9: fig06_09.c 2 Roll a six-sided die 6000 times */ 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <time.h> 6 #define SIZE /* function main begins program execution */ 9 int main() 10 { 11 int face; /* random number with value 1-6 */ 12 int roll; /* roll counter */ 13 int frequency[ SIZE ] = { 0 }; /* initialize array to 0 */ srand( time( NULL ) ); /* seed random-number generator */ /* roll die 6000 times */ 18 for ( roll = 1; roll <= 6000; roll++ ) { 19 face = rand() % 6 + 1; 20 ++frequency[ face ]; /* replaces 26-line switch of Fig. 5.8 */ 21 } /* end for */ 22 NOTE: SIZE 7, NOT 6 fig06_09.c (Part 1 of 2) 在本章中, 將出現的次數 frequency1, frequency2,... 用 frequency[ ] 取代 frequency[ 1 ] frequency[ 2 ]... frequency[ 6 ] 分別為出現點數為 的次數 此處用 ++frequency[ face ]; 取代上一頁的 switch 程式部分

24 24 23 printf( "%s%17s\n", "Face", "Frequency" ); /* output frequency elements 1-6 in tabular format */ 26 for ( face = 1; face < SIZE; face++ ) { 27 printf( "%4d%17d\n", face, frequency[ face ] ); 28 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_09.c (Part 2 of 2) Face Frequency

25 25 Character and String 字元型態 (char) char c = 'A'; /* A 為一字元常數, 用單引號包圍 */ 字串 (string) "Sweet Home", "ChE NCKU", "first" 字串要用雙引號包住, 如 "ChE NCKU" String first is really a static array of characters, 字串是由字元陣列所組成, 所以處理字串就是在處理陣列中之字元

26 26 Character Array ( 字元陣列 ) Character arrays can be initialized using string literals, e.g., char string1[ ] = "first"; Null character '\0' terminates strings ('\0' 可視為字串結束符號 ). string1 actually has 6 elements. It is equivalent to: char string1[ ] = { 'f', 'i', 'r', 's', 't', '\0' }; Individual characters can be accessed, i.e., string1[ 3 ] is character s

27 27 Character Array ( 字元陣列 ) Array name is address of array, so & is not needed for scanf scanf( "%s", string2 ); Reads characters until whitespace (such as tabs, newlines, spaces) encountered;( 因此用 scanf 讀字串時無法讀取字串中之空白 ) 如果要輸入含空白的字串, 可用 gets(string2); 來讀取字串 輸入與輸出字串 ( 字元陣列 ) 皆用 %s; 注意 : 輸入及輸出字元則用 %c!

28 1 /* Fig. 6.10: fig06_10.c 2 Treating character arrays as strings */ 3 #include <stdio.h> 4 5 /* function main begins program execution */ 6 int main() 7 { 8 char string1[ 20 ]; /* reserves 20 characters */ 9 char string2[] = "string literal"; /* reserves 15 characters */ 10 int i; /* counter */ /* read string from user into array string2 */ 13 printf("enter a string: "); 14 scanf( "%s", string1 ); /* output strings */ 17 printf( "string1 is: %s\nstring2 is: %s\n" 18 "string1 with spaces between characters is:\n", 19 string1, string2 ); /* output characters until null character is reached */ 22 for ( i = 0; string1[ i ]!= '\0'; i++ ) { 23 printf( "%c ", string1[ i ] ); 24 } /* end for */ 25 Using Character Arrays to Store and Manipulate Strings fig06_10.c (Part 1 of 2) 算算看 "string literal" 有幾個字元? 如果輸入 "Hello there",string1 會有哪些字元? 輸入與輸出字串 ( 字元陣列 ) 皆用 %s; 注意 : 輸入及輸出字元則用 %c! A space! 28

29 26 printf( "\n" ); return 0; /* indicates successful termination */ } /* end main */ Enter a string: Hello there string1 is: Hello string2 is: string literal string1 with spaces between characters is: H e l l o fig06_10.c (Part 2 of 2) 29

30 Static Local Arrays and Automatic Local Arrays 30 1 /* Fig. 6.11: fig06_11.c 2 Static arrays are initialized to zero */ 3 #include <stdio.h> 4 5 void staticarrayinit( void ); /* function prototype */ 6 void automaticarrayinit( void ); /* function prototype */ 7 8 /* function main begins program execution */ 9 int main() 10 { 11 printf( "First call to each function:\n" ); 12 staticarrayinit(); 13 automaticarrayinit(); printf( "\n\nsecond call to each function:\n" ); 16 staticarrayinit(); 17 automaticarrayinit(); return 0; /* indicates successful termination */ } /* end main */ 22 就像變數分靜態變數與區域變數一般, 陣列也有 static local array 及 automatic local arrays 的區別 fig06_11.c (Part 1 of 3)

31 23 /* function to demonstrate a static local array */ 24 void staticarrayinit( void ) 25 { 26 /* initializes elements to 0 first time function is called */ 27 static int array1[ 3 ]; 28 int i; /* counter */ printf( "\nvalues on entering staticarrayinit:\n" ); /* output contents of array1 */ 33 for ( i = 0; i <= 2; i++ ) { 34 printf( "array1[ %d ] = %d ", i, array1[ i ] ); 35 } /* end for */ printf( "\nvalues on exiting staticarrayinit:\n" ); /* modify and output contents of array1 */ 40 for ( i = 0; i <= 2; i++ ) { 41 printf( "array1[ %d ] = %d ", i, array1[ i ] += 5 ); 42 } /* end for */ } /* end function staticarrayinit */ 45 fig06_11.c (Part 2 of 3) 宣告時若沒有給初始值時, 會自動設為 0 注意此處 array1 為靜態陣列, 因此第一次進入時會自動設為 0 但離開後再進入時, 就??? 在此處陣列的內容改變了! 31

32 46 /* function to demonstrate an automatic local array */ 47 void automaticarrayinit( void ) 48 { 49 /* initializes elements each time function is called */ 50 int array2[ 3 ] = { 1, 2, 3 }; 51 int i; /* counter */ printf( "\n\nvalues on entering automaticarrayinit:\n" ); /* output contents of array2 */ 56 for ( i = 0; i <= 2; i++ ) { 57 printf("array2[ %d ] = %d ", i, array2[ i ] ); 58 } /* end for */ printf( "\nvalues on exiting automaticarrayinit:\n" ); /* modify and output contents of array2 */ 63 for ( i = 0; i <= 2; i++ ) { 64 printf( "array2[ %d ] = %d ", i, array2[ i ] += 5 ); 65 } /* end for */ } /* end function automaticarrayinit */ 此處 array2 為區域陣列 32 fig06_11.c (Part 3 of 3) 在此處陣列的內容改變了!

33 First call to each function: 33 Values on entering staticarrayinit: array1[ 0 ] = 0 array1[ 1 ] = 0 array1[ 2 ] = 0 Values on exiting staticarrayinit: array1[ 0 ] = 5 array1[ 1 ] = 5 array1[ 2 ] = 5 Program Output Values on entering automaticarrayinit: array2[ 0 ] = 1 array2[ 1 ] = 2 array2[ 2 ] = 3 Values on exiting automaticarrayinit: array2[ 0 ] = 6 array2[ 1 ] = 7 array2[ 2 ] = 8 Second call to each function: Values on entering staticarrayinit: array1[ 0 ] = 5 array1[ 1 ] = 5 array1[ 2 ] = 5 Values on exiting staticarrayinit: array1[ 0 ] = 10 array1[ 1 ] = 10 array1[ 2 ] = 10 Values on entering automaticarrayinit: array2[ 0 ] = 1 array2[ 1 ] = 2 array2[ 2 ] = 3 Values on exiting automaticarrayinit: array2[ 0 ] = 6 array2[ 1 ] = 7 array2[ 2 ] = 8

34 Call by Value Passing Variables to Functions 34 #include <stdio.h> void add10(int,int); /* add10() 的原型 */ int main() { int a = 3, b = 5; /* 宣告區域變數 a 與 b */ printf ( " 呼叫函數 add10() 之前 : " ); printf ( "a = %2d, b = %2d\n", a, b ); /* 印出 a b 的值 */ add10(a,b); printf ( " 呼叫函數 add10() 之後 : " ); printf ( "a = %2d, b = %2d\n", a, b ); /* 印出 a b 的值 */ return 0; 呼叫函數 add10() 之前 : a = 3, b = 5 } 函數 add10 中 : a = 13, b = 15 呼叫函數 add10() 之後 : a = 3, b = 5 void add10(int a,int b) { a = a + 10; /* 將變數 a 的值加 10 之後, 設回給 a */ b = b + 10; /* 將變數 b 的值加 10 之後, 設回給 b */ } printf ( " 函數 add10 中 : " ); printf ( "a = %2d, b = %2d\n", a, b ); /* 印出 a b 的值 */ 在 add10 函式中 a 及 b 這兩個變數與主程式中 a,b 所佔的記憶體位置不同

35 Passing Variables to Functions 35 當我們傳遞一般變數名稱到函數時, 接收的函數會將參數的內容複製一份到函數中變數所使用的記憶體位置中, 就像函數中區域變數一樣 ; 當函數結束後, 原先在其他區段之變數的值並不會改變 所以叫做 傳值呼叫 (call-by-value)

36 36 Passing Arrays to Functions 但當傳遞的引數為陣列名稱時, 由於陣列的長度可能很大, 為了考量執行效率, 因此傳遞到函數中的只是該陣列存放在記憶體位置的地址, 而不是將變數的內容傳到函數中, 所以叫做 傳址呼叫 (call-by-reference) 由於傳遞的是陣列的地址, 被傳遞的陣列與函數中接收的陣列有相同的記憶體位置 ( 地址 ), 所以兩個陣列的內容一樣 ; 當函數結束後, 原先在其他區段之陣列內容值已經改變了

37 Passing Arrays and Array Elements to Functions 37 Passing Arrays: To pass an array argument to a function, specify the name of the array without any brackets, void myfunction( int b[], int arraysize ) 主程式中 :... int myarray[ 24 ]; myfunction( myarray, 24 );... Array size usually passed to function also Arrays passed call-by-reference Name of array is address of first element Function knows where the array is stored Modifies original memory locations Passing Array Elements Passed by call-by-value Pass subscripted name (i.e., myarray[ 3 ]) to function

38 38 Passing Arrays to Functions Function Prototype void modifyarray( int b[], int arraysize ); Parameter names optional in prototype int b[] could be written int [] int arraysize could be simply int i.e. can be written as void modifyarray( int [], int );

39 Array Name = Address of the Array's First Element 39 1 /* Fig. 6.12: fig06_12.c 2 The name of an array is the same as &array[ 0 ] */ 3 #include <stdio.h> 4 5 /* function main begins program execution */ 6 int main() 7 { 8 char array[ 5 ]; /* define an array of size 5 */ 9 10 printf( " array = %p\n&array[0] = %p\n" 11 " &array = %p\n", 12 array, &array[ 0 ], &array ); return 0; /* indicates successful termination */ } /* end main */ fig06_12.c 用 %p 列印變數或陣列在記憶體的地址 array = 0012FF78 &array[0] = 0012FF78 &array = 0012FF78 array &array[0] 和 &array 三者的地址一樣

40 Passing Arrays and Individual Array Elements to Functions 40 1 /* Fig. 6.13: fig06_13.c 2 Passing arrays and individual array elements to functions */ 3 #include <stdio.h> 4 #define SIZE /* function prototypes */ 7 void modifyarray( int b[], int size ); 8 void modifyelement( int e ); 9 10 /* function main begins program execution */ 11 int main() 12 { 13 int a[ SIZE ] = { 0, 1, 2, 3, 4 }; /* initialize a */ 14 int i; /* counter */ printf( "Effects of passing entire array by reference:\n\nthe " 17 "values of the original array are:\n" ); /* output original array */ 20 for ( i = 0; i < SIZE; i++ ) { 21 printf( "%3d", a[ i ] ); 22 } /* end for */ printf( "\n" ); 25 fig06_13.c (Part 1 of 3) 此處也可寫為 void modifyarray( int [], int ); void modifyelement( int );

41 26 /* pass array a to modifyarray by reference */ 27 modifyarray( a, SIZE ); printf( "The values of the modified array are:\n" ); /* output modified array */ 32 for ( i = 0; i < SIZE; i++ ) { 33 printf( "%3d", a[ i ] ); 34 } /* end for */ /* output value of a[ 3 ] */ 37 printf( "\n\n\neffects of passing array element " 38 "by value:\n\nthe value of a[3] is %d\n", a[ 3 ] ); modifyelement( a[ 3 ] ); /* pass array element a[ 3 ] by value */ /* output value of a[ 3 ] */ 43 printf( "The value of a[ 3 ] is %d\n", a[ 3 ] ); return 0; /* indicates successful termination */ } /* end main */ 48 將陣列名稱 ( 事實上是地址 ) 及大小傳到函數中, 此時為傳址呼叫! fig06_13.c (Part 2 of 3) 在這裡, 傳遞的是陣列中某一個元素, 此時為傳值呼叫! 41

42 49 /* in function modifyarray, "b" points to the original array "a" 50 in memory */ 51 void modifyarray( int b[], int size ) 52 { 53 int j; /* counter */ /* multiply each array element by 2 */ 56 for ( j = 0; j < size; j++ ) { 57 b[ j ] *= 2; 58 } /* end for */ } /* end function modifyarray */ 61 改變陣列的內容 62 /* in function modifyelement, "e" is a local copy of array element 63 a[ 3 ] passed from main */ 64 void modifyelement( int e ) 65 { 66 /* multiply parameter by 2 */ 67 printf( "Value in modifyelement is %d\n", e *= 2 ); 68 } /* end function modifyelement */ 42 fig06_13.c (Part 3 of 3) 改變整數區域變數 e 的內容

43 Effects of passing entire array by reference: 43 The values of the original array are: The values of the modified array are: Program Output Effects of passing array element by value: The value of a[3] is 6 Value in modifyelement is 12 The value of a[ 3 ] is 6

44 Type Qualifier - const 44 1 /* Fig. 6.14: fig06_14.c 2 Demonstrating the const type qualifier with arrays */ 3 #include <stdio.h> 4 5 void trytomodifyarray( const int b[] ); /* function prototype */ 6 7 /* function main begins program execution */ 8 int main() 9 { 10 int a[] = { 10, 20, 30 }; /* initialize a */ trytomodifyarray( a ); printf("%d %d %d\n", a[ 0 ], a[ 1 ], a[ 2 ] ); return 0; /* indicates successful termination */ } /* end main */ 19 fig06_14.c (Part 1 of 2) 當宣告變數或陣列時使用 const 這個修飾詞後, 該變數或陣列就宣告成為常數或常數陣列, 它們的內容在程式執行時就不容更改! 當主程式呼叫函式時, 如果函式的引數 (arguments) 是利用陣列傳遞時, 只要在函式中陣列的值改變的話, 主程式中對應的陣列值也會跟著改變 如果要避免主程式的陣列值改變, 這時在函式中可宣告該陣列為常數陣列

45 20 /* in function trytomodifyarray, array b is const, so it cannot be 21 used to modify the original array a in main. */ 22 void trytomodifyarray( const int b[] ) 23 { 24 b[ 0 ] /= 2; /* error */ 25 b[ 1 ] /= 2; /* error */ 26 b[ 2 ] /= 2; /* error */ 27 } /* end function trytomodifyarray */ Compiling... FIG06_14.C fig06_14.c(24) : error C2166: l-value specifies const object fig06_14.c(25) : error C2166: l-value specifies const object fig06_14.c(26) : error C2166: l-value specifies const object 45 fig06_14.c (Part 2 of 2) Program Output 在本函數中, b 已經宣告型態為 const int 的常數型整數陣列, 但在程式中又試圖改變 b 的內容, 因此產生語法錯誤!

46 46 Sorting Arrays ( 排序 ) Sorting Data Important computing application Virtually every organization must sort some data Bubble Sort ( 氣泡排序法 Sinking Sort) Several passes through the array Successive pairs ( 鄰近的兩個 ) of elements are compared If increasing order (or identical ), no change If decreasing order, elements exchanged Repeat Example: original: pass 1: pass 2: Small elements bubble to the top

47 Sorting an Array with Bubble Sort 47 1 /* Fig. 6.15: fig06_15.c 2 This program sorts an array's values into ascending order */ 3 #include <stdio.h> 4 #define SIZE /* function main begins program execution */ 7 int main() 8 { 9 /* initialize a */ 10 int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 11 int i; /* inner counter */ 12 int pass; /* outer counter */ 13 int hold; /* temporary location used to swap array elements */ printf( "Data items in original order\n" ); /* output original array */ 18 for ( i = 0; i < SIZE; i++ ) { 19 printf( "%4d", a[ i ] ); 20 } /* end for */ 21 要將本陣列之值由小至大排序 首先, 列印原始陣列 fig06_15.c (Part 1 of 3)

48 22 /* bubble sort */ 23 /* loop to control number of passes */ 24 for ( pass = 1; pass < SIZE; pass++ ) { /* loop to control number of comparisons per pass */ 27 for ( i = 0; i < SIZE - 1; i++ ) { /* compare adjacent elements and swap them if first 30 element is greater than second element */ 31 if ( a[ i ] > a[ i + 1 ] ) { 32 hold = a[ i ]; 33 a[ i ] = a[ i + 1 ]; 34 a[ i + 1 ] = hold; 35 } /* end if */ } /* end inner for */ } /* end outer for */ printf( "\ndata items in ascending order\n" ); 42 若只寫 a[ i ] = a[ i + 1 ]; a[ i + 1 ] = a [ i ]; 會發生什麼結果? 能不能提高本程式的執行效率? 48 fig06_15.c (Part 2 of 3)

49 43 /* output sorted array */ 44 for ( i = 0; i < SIZE; i++ ) { 45 printf( "%4d", a[ i ] ); 46 } /* end for */ printf( "\n" ); return 0; /* indicates successful termination */ 51 Data items in original order Data items in ascending order 最後列印排序完成後的陣列 fig06_15.c (Part 3 of 3) Program Output 49

50 Case Study: Computing Mean, Median and Mode Using Arrays 50 Mean ( 算術平均值 ) average Median ( 中間數 ) number in middle of sorted list 1, 2, 3, 4, 5 3 is the median 1, 1, 1, 4, 5, 5, 10 4 is the median Mode ( 最常出現之值 ) number that occurs most often 1, 1, 1, 2, 3, 3, 4, 5 1 is the mode

51 Computing Mean, Median and Mode Using Arrays 51 1 /* Fig. 6.16: fig06_16.c 2 This program introduces the topic of survey data analysis. 3 It computes the mean, median, and mode of the data */ 4 #include <stdio.h> 5 #define SIZE /* function prototypes */ 8 void mean( const int answer[] ); 9 void median( int answer[] ); 10 void mode( int freq[], const int answer[] ) ; 11 void bubblesort( int a[] ); 12 void printarray( const int a[] ); /* function main begins program execution */ 15 int main() 16 { 17 int frequency[ 10 ] = { 0 }; /* initialize array frequency */ 18 有 99 個數值介於 1 ~ 9 的原始數據 各個函數之原型 (prototype) mean median mode bubblesort printarray fig06_16.c (Part 1 of 8) 平均值中間數最多數陣列排序列印陣列

52 19 /* initialize array response */ 20 int response[ SIZE ] = 21 { 6, 7, 8, 9, 8, 7, 8, 9, 8, 9, 22 7, 8, 9, 5, 9, 8, 7, 8, 7, 8, 23 6, 7, 8, 9, 3, 9, 8, 7, 8, 7, 24 7, 8, 9, 8, 9, 8, 9, 7, 8, 9, 25 6, 7, 8, 7, 8, 7, 9, 8, 9, 2, 26 7, 8, 9, 8, 9, 8, 9, 7, 5, 3, 27 5, 6, 7, 2, 5, 3, 9, 4, 6, 4, 28 7, 8, 9, 6, 8, 7, 8, 9, 7, 8, 29 7, 4, 4, 2, 5, 3, 8, 7, 5, 6, 30 4, 5, 6, 1, 6, 5, 7, 8, 7 }; /* process responses */ 33 mean( response ); 34 median( response ); 35 mode( frequency, response ); return 0; /* indicates successful termination */ } /* end main */ fig06_16.c (Part 2 of 8) 有 99 個數值介於 1 ~ 9 的原始數據分別呼叫計算 mean, median 及 mode 的函數

53 41 /* calculate average of all response values */ 42 void mean( const int answer[] ) 43 { 44 int j; /* counter */ 45 int total = 0; /* variable to hold sum of array elements */ printf( "%s\n%s\n%s\n", "********", " Mean", "********" ); /* total response values */ 50 for ( j = 0; j < SIZE; j++ ) { 51 total += answer[ j ]; 52 } /* end for */ printf( "The mean is the average value of the data\n" 55 "items. The mean is equal to the total of\n" 56 "all the data items divided by the number\n" 57 "of data items ( %d ). The mean value for\n" 58 "this run is: %d / %d = %.4f\n\n", 59 SIZE, total, SIZE, ( double ) total / SIZE ); 60 } /* end function mean */ 61 本函數中陣列 answer 的內容不會改變, 故可用 const 修飾字 計算總和 53 fig06_16.c (Part 3 of 8) 計算平均值, 注意此處用 (double) 把整數型態的數據轉成倍精準浮點數 在函數中, 輸入陣列的大小要如何決定?

54 62 /* sort array and determine median element's value */ 63 void median( int answer[] ) 64 { 65 printf( "\n%s\n%s\n%s\n%s", 66 "********", " Median", "********", 67 "The unsorted array of responses is" ); printarray( answer ); /* output unsorted array */ bubblesort( answer ); /* sort array */ printf( "\n\nthe sorted array is" ); 74 printarray( answer ); /* output sorted array */ /* display median element */ 77 printf( "\n\nthe median is element %d of\n" 78 "the sorted %d element array.\n" 79 "For this run the median is %d\n\n", 80 SIZE / 2, SIZE, answer[ SIZE / 2 ] ); 81 } /* end function median */ 82 利用本函數排序並決定中間數, 所以在本函數中, 陣列 answer 的內容會被排序而更改, 不可用 const 修飾字 fig06_16.c (Part 4 of 8) 利用 bubblesort 函數排序 排序後找中間值 54 Note 99/2=49 如果陣列中元素的個數為偶數時, 本程式找出的中間值是哪個位置?

55 83 /* determine most frequent response */ 84 void mode( int freq[], const int answer[] ) 85 { 86 int rating; /* counter */ 87 int j; /* counter */ 88 int h; /* counter */ 89 int largest = 0; /* represents largest frequency */ 90 int modevalue = 0; /* respesents most frequent response */ printf( "\n%s\n%s\n%s\n", 93 "********", " Mode", "********" ); /* initialize frequencies to 0 */ 96 for ( rating = 1; rating <= 9; rating++ ) { 97 freq[ rating ] = 0; 98 } /* end for */ /* summarize frequencies */ 101 for ( j = 0; j < SIZE; j++ ) { freq[ answer[ j ] ]; 103 } /* end for */ 104 找最常出現的值的函數 先將計數器設為 0 55 fig06_16.c (Part 5 of 8) freq[1], freq[2],...freq[9] 為分別出現 1, 2,... 9 的次數 ; 此處即是分別計數的部份

56 105 /* output headers for result columns */ 106 printf( "%s%11s%19s\n\n", 107 "Response", "Frequency", "Histogram"); /* output results */ 111 for ( rating = 1; rating <= 9; rating++ ) { 112 printf( "%8d%11d ", rating, freq[ rating ] ); /* keep track of mode value and largest frequency value */ 115 if ( freq[ rating ] > largest ) { 116 largest = freq[ rating ]; 117 modevalue = rating; 118 } /* end if */ /* output histogram bar representing frequency value */ 121 for ( h = 1; h <= freq[ rating ]; h++ ) { 122 printf( "*" ); 123 } /* end inner for */ printf( "\n" ); /* being new line of output */ 126 } /* end outer for */ fig06_16.c (Part 6 of 8) rating = 1 到 9 的迴圈 ; 在此迴圈中, 尋找出現最多次數之值以及繪長條圖 (1) 找 freq[1], freq[2],...freq[9] 最大值 (2) 分別畫 histogram

57 128 /* display the mode value */ 129 printf( "The mode is the most frequent value.\n" 130 "For this run the mode is %d which occurred" 131 " %d times.\n", modevalue, largest ); 132 } /* end function mode */ /* function that sorts an array with bubble sort algorithm */ 135 void bubblesort( int a[] ) 136 { 137 int pass; /* counter */ 138 int j; /* counter */ 139 int hold; /* temporary location used to swap elements */ /* loop to control number of passes */ 142 for ( pass = 1; pass < SIZE; pass++ ) { /* loop to control number of comparisons per pass */ 145 for ( j = 0; j < SIZE - 1; j++ ) { /* swap elements if out of order */ 148 if ( a[ j ] > a[ j + 1 ] ) { 149 hold = a[ j ]; 150 a[ j ] = a[ j + 1 ]; 151 a[ j + 1 ] = hold; 152 } /* end if */ 153 再列印出現最多次的值及次數 Bubble Sort 部分與前面的例子相同, 此處只是將它寫成函數 fig06_16.c (Part 7 of 8) 57

58 154 } /* end inner for */ } /* end outer for */ } /* end function bubblesort */ /* output array contents (20 values per row) */ 161 void printarray( const int a[] ) 162 { 163 int j; /* counter */ /* output array contents */ 166 for ( j = 0; j < SIZE; j++ ) { if ( j % 20 == 0 ) { /* begin new line every 20 values */ 169 printf( "\n" ); 170 } /* end if */ printf( "%2d", a[ j ] ); 173 } /* end for */ } /* end function printarray */ fig06_16.c (Part 8 of 8) 利用這個函數是把陣列 a 列印出來 每行列印 20 個元素 58

59 ******** Mean ******** The mean is the average value of the data items. The mean is equal to the total of all the data items divided by the number of data items ( 99 ). The mean value for this run is: 681 / 99 = Program Output 59 ******** Median ******** The unsorted array of responses is The sorted array is

60 The median is element 49 of the sorted 99 element array. For this run the median is 7 60 ******** Mode ******** Response Frequency Histogram Program Output (continued) 1 1 * 2 3 *** 3 4 **** 4 5 ***** 5 8 ******** 6 9 ********* 7 23 *********************** 8 27 *************************** 9 19 ******************* The mode is the most frequent value. For this run the mode is 8 which occurred 27 times.

61 Searching Arrays: Linear Search and Binary Search Search an array for a key value Linear search ( 線性搜尋法 ) Simple Compare each element of array with key value Useful for small and unsorted arrays Binary search ( 二分搜尋法 ) For sorted arrays Compares middle element with key If equal, match found If key < middle, looks in first half of array If key > middle, looks in last half Repeat Very fast; at most n steps, where 2 n > number of elements 30 element array takes at most 5 steps 2 5 > 30 so at most 5 steps 1,000,000,000 element array takes at most 30 steps ( 2 30 =1,073,741,824) On the other hand, 1,000,000,000 element array searched by linear search method takes in average 500,000,000 comparisons. 61

62 Linear Search of an Array 62 1 /* Fig. 6.18: fig06_18.c 2 Linear search of an array */ 3 #include <stdio.h> 4 #define SIZE /* function prototype */ 7 int linearsearch( const int array[], int key, int size ); 8 9 /* function main begins program execution */ 10 int main() 11 { 12 int a[ SIZE ]; /* create array a */ 13 int x; /* counter */ 14 int searchkey; /* value to locate in a */ 15 int element; /* variable to hold location of searchkey or -1 */ /* create data */ 18 for ( x = 0; x < SIZE; x++ ) { 19 a[ x ] = 2 * x; 20 } /* end for */ printf( "Enter integer search key:\n" ); 23 scanf( "%d", &searchkey ); 24 fig06_18.c (Part 1 of 3) 製造一組一百個元素 { 0, 2, 4, 6,..., 198 } 的陣列 由鍵盤輸入一個要搜尋的數字

63 25 /* attempt to locate searchkey in array a */ 26 element = linearsearch( a, searchkey, SIZE ); /* display results */ 29 if ( element!= -1 ) { 30 printf( "Found value in element %d\n", element ); 31 } /* end if */ 32 else { 33 printf( "Value not found\n" ); 34 } /* end else */ return 0; /* indicates successful termination */ } /* end main */ 39 呼叫 linearsearch 函數尋找 searchkey 列印結果 63 fig06_18.c (Part 2 of 3)

64 64 40 /* compare key to every element of array until the location is found 41 or until the end of array is reached; return subscript of element 42 if key or -1 if key is not found */ 43 int linearsearch( const int array[], int key, int size ) 44 { 45 int n; /* counter */ fig06_18.c (Part 3 of 3) /* loop through array */ 48 for ( n = 0; n < size; ++n ) { if ( array[ n ] == key ) { 51 return n; /* return location of key */ 52 } /* end if */ } /* end for */ return -1; /* key not found */ } /* end function linearsearch */ Enter integer search key: 36 Found value in element 18 如果陣列中有多筆相同資料時,... Enter integer search key: 37 Value Copyright not found by Deitel

65 Binary Search of a Sorted Array 65 1 /* Fig. 6.19: fig06_19.c 2 Binary search of an array */ 3 #include <stdio.h> 4 #define SIZE /* function prototypes */ 7 int binarysearch( const int b[], int searchkey, int low, int high ); 8 void printheader( void ); 9 void printrow( const int b[], int low, int mid, int high ); /* function main begins program execution */ 12 int main() 13 { 14 int a[ SIZE ]; /* create array a */ 15 int i; /* counter */ 16 int key; /* value to locate in array a */ 17 int result; /* variable to hold location of key or -1 */ /* create data */ 20 for ( i = 0; i < SIZE; i++ ) { 21 a[ i ] = 2 * i; 22 } /* end for */ printf( "Enter a number between 0 and 28: " ); 25 scanf( "%d", &key ); 26 fig06_19.c (Part 1 of 5) 製造一組 { 0, 2, 4, 6,..., 28 } 的陣列, 注意本陣列已經按大小排序, 如果要用二分法對陣列搜尋, 必須要把該陣列按大小先排序後再搜尋 因此, 利用二分法搜尋未排序陣列最花時間的地方就是先將該陣列排序的時間

66 27 printheader(); /* search for key in array a */ 30 result = binarysearch( a, key, 0, SIZE - 1 ); /* display results */ 33 if ( result!= -1 ) { 34 printf( "\n%d found in array element %d\n", key, result ); 35 } /* end if */ 36 else { 37 printf( "\n%d not found\n", key ); 38 } /* end else */ return 0; /* indicates successful termination */ } /* end main */ /* function to perform binary search of an array */ 45 int binarysearch( const int b[], int searchkey, int low, int high ) 46 { 47 int middle; /* variable to hold middle element of array */ 48 呼叫 binarysearch 函數在陣列 a 中尋找 key 在哪裡 fig06_19.c (Part 2 of 5) binarysearch 函數在陣列 a 中尋找 searchkey 在哪裡 ; low 及 high 為陣列 a 中位置編號的上下限 66

67 49 /* loop until low subscript is greater than high subscript */ 50 while ( low <= high ) { /* determine middle element of subarray being searched */ 53 middle = ( low + high ) / 2; /* display subarray used in this loop iteration */ 56 printrow( b, low, middle, high ); /* if searchkey matched middle element, return middle */ 59 if ( searchkey == b[ middle ] ) { 60 return middle; 61 } /* end if */ /* if searchkey less than middle element, set new high */ 64 else if ( searchkey < b[ middle ] ) { 65 high = middle - 1; /* search low end of array */ 66 } /* end else if */ /* if searchkey greater than middle element, set new low */ 69 else { 70 low = middle + 1; /* search high end of array */ 71 } /* end else */ } /* end while */ 74 fig06_19.c (Part 3 of 5) Compares middle element with key Repeat If equal, match found If key < middle, looks in first half of array If key > middle, looks in last half 67

68 75 return -1; /* searchkey not found */ } /* end function binarysearch */ /* Print a header for the output */ 80 void printheader( void ) 81 { 82 int i; /* counter */ printf( "\nsubscripts:\n" ); /* output column head */ 87 for ( i = 0; i < SIZE; i++ ) { 88 printf( "%3d ", i ); 89 } /* end for */ printf( "\n" ); /* start new line of output */ /* output line of - characters */ 94 for ( i = 1; i <= 4 * SIZE; i++ ) { 95 printf( "-" ); 96 } /* end for */ printf( "\n" ); /* start new line of output */ 99 } /* end function printheader */ 100 A space fig06_19.c (Part 4 of 5) Subscripts:

69 101 /* Print one row of output showing the current 102 part of the array being processed. */ 103 void printrow( const int b[], int low, int mid, int high ) 104 { 105 int i; /* counter */ 4 spaces /* loop through entire array */ 108 for ( i = 0; i < SIZE; i++ ) { /* display spaces if outside current subarray range */ 111 if ( i < low i > high ) { 112 printf( " " ); 113 } /* end if */ 114 else if ( i == mid ) { /* display middle element */ 115 printf( "%3d*", b[ i ] ); /* mark middle value */ 116 } /* end else if */ 117 else { /* display other elements in subarray */ 118 printf( "%3d ", b[ i ] ); 119 } /* end else */ Note! } /* end for */ printf( "\n" ); /* start new line of output */ 124 } /* end function printrow */ fig06_19.c (Part 5 of 5) 69

70 Enter a number between 0 and 28: Subscripts: * * * 28 24* Program Output 25 not found Enter a number between 0 and 28: 8 Subscripts: * * * 12 8* 8 found in array element 4

71 Enter a number between 0 and 28: 6 71 Subscripts: * * Program Output (continued) 6 found in array element 3

72 72 Multiple-Subscripted Arrays Multiple Subscripted Arrays Tables with rows ( 列 ) and columns ( 行 )(m by n array) m 列 n 行 Like matrices: specify row, then column In a double subscripted array, each row is basically a single-subscripted array.

73 73 Initialization Multiple-Subscripted Arrays int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } }; Initializers grouped by row in braces If not enough, unspecified elements set to zero int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } }; Referencing Elements Specify row ( 列 ), then column ( 行 ) printf( "%d", b[ 0 ][ 1 ] );

74 Initializing Multi-Dimensional Arrays 74 1 /* Fig. 6.21: fig06_21.c 2 Initializing multidimensional arrays */ 3 #include <stdio.h> 4 5 void printarray( const int a[][ 3 ] ); /* function prototype */ 6 7 /* function main begins program execution */ 8 int main() 9 { 10 /* initialize array1, array2, array3 */ 11 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } }; 12 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 }; 13 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; printf( "Values in array1 by row are:\n" ); 16 printarray( array1 ); printf( "Values in array2 by row are:\n" ); 19 printarray( array2 ); printf( "Values in array3 by row are:\n" ); 22 printarray( array3 ); return 0; /* indicates successful termination */ } /* end main */ 27 fig06_21.c (Part 1 of 2)

75 28 /* function to output array with two rows and three columns */ 29 void printarray( const int a[][ 3 ] ) 30 { 31 int i; /* counter */ 32 int j; /* counter */ /* loop through rows */ 35 for ( i = 0; i <= 1; i++ ) { /* output column values */ 38 for ( j = 0; j <= 2; j++ ) { 39 printf( "%d ", a[ i ][ j ] ); 40 } /* end inner for */ printf( "\n" ); /* start new line of output */ 43 } /* end outer for */ } /* end function printarray */ Values in array1 by row are: Values in array2 by row are: Values in array3 by row are: C 語言中允許二維與二維以上的多維陣列可以省略第一個 ( 即最左邊 ) 的索引值, 但是其他的索引值必須填寫! 列印第 i 列 (row ) 列印第 i 列中第 j 行 (column ) 為什麼最左邊的索引值可忽略, 但是其他的索引值必須填寫? fig06_21.c (Part 2 of 2) Program Output 75

76 1 /* Fig. 6.22: fig06_22.c 2 Double-subscripted array example */ 3 #include <stdio.h> 4 #define STUDENTS 3 5 #define EXAMS /* function prototypes */ 8 int minimum( const int grades[][ EXAMS ], int pupils, int tests ); 9 int maximum( const int grades[][ EXAMS ], int pupils, int tests ); 10 double average( const int setofgrades[], int tests ); 11 void printarray( const int grades[][ EXAMS ], int pupils, int tests ); /* function main begins program execution */ 14 int main() 15 { 16 int student; /* counter */ /* initialize student grades for three students (rows) */ 19 const int studentgrades[ STUDENTS ][ EXAMS ] = 20 { { 77, 68, 86, 73 }, 21 { 96, 87, 89, 78 }, 22 { 70, 90, 86, 81 } }; 23 Example of Double-Subscripted Array 三位學生, 四次考試 ; 把他們的考試分數用陣列儲存 宣告並給成績陣列 76 fig06_22.c (Part 1 of 6) 甲同學的分數 乙同學的分數 丙同學的分數

77 77 24 /* output array studentgrades */ 25 printf( "The array is:\n" ); 26 printarray( studentgrades, STUDENTS, EXAMS ); /* determine smallest and largest grade values */ 29 printf( "\n\nlowest grade: %d\nhighest grade: %d\n", 30 minimum( studentgrades, STUDENTS, EXAMS ), 31 maximum( studentgrades, STUDENTS, EXAMS ) ); /* calculate average grade for each student */ 34 for ( student = 0; student <= STUDENTS - 1; student++ ) { 35 printf( "The average grade for student %d is %.2f\n", 36 student, average( studentgrades[ student ], EXAMS ) ); 37 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ 42 找所有成績的最高及最低分數 計算個別學生的平均分數 fig06_22.c (Part 2 of 6) 甲同學的分數 乙同學的分數 丙同學的分數 注意在呼叫 average 函數計算個別學生的平均分數時, 只用 studentgrades[ student ] 單維陣列型態 ; In a double subscripted array, each row is basically treated as a single-subscripted array. 此時 studentgrades[ 0 ] 表示傳入 studentgrades 陣列中第 0 列第 0 行的地址到函數中 ; studentgrades[ 1 ] 表示傳入 studentgrades 陣列中第 1 列第 0 行的地址到函數中 ; studentgrades[ 2 ] 表示傳入 studentgrades 陣列中第 2 列第 0 行的地址到函數中 ;

78 Function minimum /* Find the minimum grade */ 44 int minimum( const int grades[][ EXAMS ], int pupils, int tests ) 45 { 46 int i; /* counter */ 47 int j; /* counter */ 48 int lowgrade = 100; /* initialize to highest possible grade */ /* loop through rows of grades */ 51 for ( i = 0; i < pupils; i++ ) { /* loop through columns of grades */ 54 for ( j = 0; j < tests; j++ ) { if ( grades[ i ][ j ] < lowgrade ) { 57 lowgrade = grades[ i ][ j ]; 58 } /* end if */ } /* end inner for */ } /* end outer for */ return lowgrade; /* return minimum grade */ } /* end function minimum */ 67 fig06_22.c (Part 3 of 6)

79 Function maximum /* Find the maximum grade */ 69 int maximum( const int grades[][ EXAMS ], int pupils, int tests ) 70 { 71 int i; /* counter */ 72 int j; /* counter */ 73 int highgrade = 0; /* initialize to lowest possible grade */ /* loop through rows of grades */ 76 for ( i = 0; i < pupils; i++ ) { /* loop through columns of grades */ 79 for ( j = 0; j < tests; j++ ) { if ( grades[ i ][ j ] > highgrade ) { 82 highgrade = grades[ i ][ j ]; 83 } /* end if */ } /* end inner for */ } /* end outer for */ return highgrade; /* return maximum grade */ } /* end function maximum */ fig06_22.c (Part 4 of 6)

80 Function average /* Determine the average grade for a particular student */ 94 double average( const int setofgrades[], int tests ) 95 { 96 int i; /* counter */ 97 int total = 0; /* sum of test grades */ /* total all grades for one student */ 100 for ( i = 0; i < tests; i++ ) { 101 total += setofgrades[ i ]; 102 } /* end for */ return ( double ) total / tests; /* average */ } /* end function average */ fig06_22.c (Part 5 of 6)

81 Function printarray /* Print the array */ 109 void printarray( const int grades[][ EXAMS ], int pupils, int tests ) 110 { 111 int i; /* counter */ 112 int j; /* counter */ /* output column heads */ 115 printf( " [0] [1] [2] [3]" ); /* output grades in tabular format */ 118 for ( i = 0; i < pupils; i++ ) { /* output label for row */ 121 printf( "\nstudentgrades[%d] ", i ); /* output grades for one student */ 124 for ( j = 0; j < tests; j++ ) { 125 printf( "%-5d", grades[ i ][ j ] ); 126 } /* end inner for */ } /* end outer for */ } /* end function printarray */ fig06_22.c (Part 6 of 6) %-5d 的意思是預留 5 個位置顯示整數, 並從左邊開始顯示 The array is: [0] [1] [2] [3] studentgrades[0] studentgrades[1] studentgrades[2]

82 82 The array is: [0] [1] [2] [3] studentgrades[0] studentgrades[1] studentgrades[2] Lowest grade: 68 Highest grade: 96 The average grade for student 0 is The average grade for student 1 is The average grade for student 2 is 81.75

83 Review In this chapter, you have learned: The array data structure. The use of arrays to store, sort and search lists and tables of values. Bubble Sort, Exchanger Sort (in exercise) Linear Search, Binary Search How to define an array, initialize an array and refer to individual elements of an array. 足標 (subscript, 索引值 ) 從 0 開始! Character Arrays ( 字元陣列 ) ; char string1[] = "first"; char string1[] = { 'f', 'i', 'r', 's', 't', '\0' }; To pass arrays to functions. 傳遞的是陣列的地址 ;Call-by-Reference! The basic sorting and searching techniques. To define and manipulate multiple subscript arrays. 83