Chapter 6. Arrays. Copyright 2007 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
|
|
- Randell Peters
- 6 years ago
- Views:
Transcription
1 1 Chapter 6 Arrays Copyright 2007 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
2 2 Chapter 6 - Arrays 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
3 3 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.
4 4 6.1 Introduction Arrays Structures of related data items Static entity same size throughout program Dynamic data structures discussed in Chapter 12
5 6.2 Arrays Array Group of consecutive memory locations Same name and type To refer to an element, specify Array name Position number Format: arrayname[ position number ] First element at position 0 nelement array named c: c[ 0 ], c[ 1 ]...c[ n 1 ] Name of array (Note that all elements of this array have the same name, c) c[0] c[1] c[2] c[3] c[4] c[5] c[6] c[7] c[8] c[9] c[10] c[11] -45 Position number of the element within array c
6 6 Example: Array Declaration and Initialization METHOD - 1: int c[12] = {-45,6,0,72,1543,-89,0,62,-3,1,6453,78}; METHOD - 2: int c[12]; C[0] = -45; C[1] = 6; C[2] = 0; C[3] = 72; C[11] = 78; METHOD - 3: int c[12], i; for (i=0; i <= 11; i++) { printf( Enter element - %d, i); scanf( %d, &c[i]); }
7 7 6.2 Arrays Array elements are like normal variables c[ 0 ] = 3; printf( "%d", c[ 0 ] ); Perform operations in subscript. If x equals 3 c[ 5-2 ] == c[ 3 ] == c[ x ]
8 8 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.
9 9 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 ];
10 Examples Using Arrays Initializers int a[ 5 ] = { 10, 20, 30, 40, 50 }; If not enough initializers, rightmost elements become 0 int a[ 5 ] = { 0 }; // All elements are 0 int a[ 5 ] = { 10 }; // First element is 10, other elements are 0 If too many elements, then a syntax error is produced C arrays have no bounds checking If size omitted, initializers determine it int a[ ] = { 10, 20, 30, 40, 50 }; 5 initializers, therefore compiler knows that array has 5 elements
11 1 /* Fig. 6.3: fig06_03.c 2 initializing an array */ 3 #include <stdio.h> 4 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" n", "Element", "Value" ); /* output contents of array n in tabular format */ 19 for ( i = 0; i < 10; i++ ) { 20 printf( "%7d%13d\n" n", i, n[ i ] ); 21 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_03.c 11
12 Element Value Program Output 12
13 Examples Using Arrays Character arrays String first is really a static array of characters Character arrays can be initialized using string literals char string1[] = "first"; Null character '\0' terminates strings string1 actually has 6 elements It is equivalent to char string1[] ={'f','i','r','s','t','\0'}; Can access individual characters string1[ 3 ] is character s Array name is address of array, so & not needed for scanf scanf( "%s", string2 ); Reads characters until whitespace encountered Can write beyond end of array, be careful
14 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" n", "Element", "Value" ); /* output contents of array in tabular format */ 15 for ( i = 0; i < 10; i++ ) { 16 printf( "%7d%13d\n" n", i, n[ i ] ); 17 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_04.c 14
15 Element Value Program Output 15
16 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" n", "Element", "Value" ); /* output contents of array s in tabular format */ 20 for ( j = 0; j < SIZE; j++ j ) { 21 printf( "%7d%13d\n" n", j, s[ j ] ); 22 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ fig06_05.c 16
17 Element Value Program Output 17
18 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 ialize 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 ZE; i++ ) { 16 total += a[ i ]; 17 } /* end for */ printf( "Total of array element values is %d\n" n", total ); return 0; /* indicates successful termination */ } /* end main */ Total of array element values is 383 fig06_06.c Program Output 18
19 1 /* Fig. 6.7: fig06_07.c 2 Student poll (ANKET) program */ 3 #include <stdio.h> 4 #define RESPONSE_SIZE 200 /* 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 fig06_07.c (Part 1 of 2) 19
20 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" n", "Rating", "Frequency" ); /* output frequencies in tabular format */ 32 for ( rating = 1; rating < FREQUENCY_SIZE; rating++ ) { 33 printf( "%6d%17d\n" n", rating, frequency[ rating - 1 ] ); 34 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ Rating Frequency fig06_07.c (Part 2 of 2) Program Output 20
21 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" 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 fig06_08.c (Part 1 of 2) 21
22 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 22
23 1 /* Fig. 6.9: fig06_09.c 2 Roll a six-sided 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 om-number generator */ /* roll die 6000 times */ 18 for ( roll = 1; roll <= 6000; roll++ ) { 19 face = rand() % 6 + 1; 20 ++frequency[ face - 1 ]; /* replaces 26-line switch of Fig. 5.8 */ 21 } /* end for */ printf( "%s%17s\n" n", "Face", "Frequency" ); 24 fig06_09.c (Part 1 of 2) 23
24 25 /* output frequency elements in tabular format */ 26 for ( face = 1; face < SIZE; face++ ) { 27 printf( "%4d%17d\n" n", face, frequency[ face - 1 ] ); 28 } /* end for */ return 0; /* indicates successful termination n */ } /* end main */ Face Frequency fig06_09.c (Part 2 of 2) Program Output 24
25 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" n", 19 string1, string2 ); /* output characters until null character is reached */ 22 for ( i = 0; string1[ i ]!= '\0' 0'; i++ ) { 23 printf( "%c ", " string1[ i ] ); 24 } /* end for */ 25 fig06_10.c (Part 1 of 2) 25
26 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) 26
27 Example: Statistical Calculations 27 Get student scores from user (store into an array) Calculate the followings Avg N X i= ( x) = 1 N i Variance = N i= 1 ( x i x) N 1 2 Standard deviation = Variance Absolute deviation N i= = 1 x i N x
28 28 Example: Statistical Calculations #include <stdio.h> #include <stdlib.h> #include <math.h> // fabs,sqrt #define MAXSTUDENTS 100 int main() { int score[maxstudents]; int N = 0; // Number of students float avg, variance, std_dev, abs_dev; float total = 0.0, sqr_total = 0.0, abs_total = 0.0; int i = 0; printf("how many students are there? "); scanf("%d", &N); for (i = 0; i < N; i++) { printf("enter grade of student # %d : ", i + 1); scanf("%d", &score[i]); total = total + score[i]; }
29 Example: Statistical Calculations (cont.) 29 avg = total / N; for (i = 0; i < N; i++) { sqr_total = sqr_total + (score[i] - avg) * (score[i] - avg); abs_total = abs_total + fabs(score[i] - avg); } variance = sqr_total / (N - 1); std_dev = sqrt(variance); abs_dev = abs_total / N; printf("average = %f\n", avg); printf("variance = %f\n", variance); printf("standard deviation = %f\n", std_dev); printf("absolute deviation = %f\n", abs_dev); } system("pause"); return 0;
30 Example: Statistical Calculations (Output) 30 How many students are there? 4 Enter grade of student # 1 : 92 Enter grade of student # 2 : 62 Enter grade of student # 3 : 70 Enter grade of student # 4 : 51 Average = Variance = Standard deviation = Absolute deviation =
31 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" n" ); 12 staticarrayinit(); 13 automaticarrayinit(); printf( "\n\nsecond nsecond call to each function:\n" n" ); 16 staticarrayinit(); ticarrayinit(); 17 automaticarrayinit(); return 0; /* indicates successful termination */ } /* end main */ 22 fig06_11.c (Part 1 of 3) 31
32 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" 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 e staticarrayinit:\n" 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) 32
33 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 nvalues on entering automaticarrayinit:\n" 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" 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 f automaticarrayinit */ fig06_11.c (Part 3 of 3) 33
34 First call to each function: 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 34 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
35 Passing Arrays to Functions Passing arrays To pass an array argument to a function, specify the name of the array without any brackets int myarray[ 24 ]; myfunction( myarray, 24 ); Array size usually passed to function 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
36 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
37 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" n", 12 array, &array[ 0 ], &array ); return 0; /* indicates successful termination */ } /* end main */ array = 0012FF78 &array[0] = 0012FF78 &array = 0012FF78 fig06_12.c Program Output 37
38 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 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) 38
39 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 ZE; i++ ) { 33 printf( "%3d", a[ i ] ); 34 } /* end for */ /* output value of a[ 3 ] */ 37 printf( "\n\n\neffects neffects of passing array element " 38 "by value:\n\nthe nthe value of a[3] is %d\n" 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" n", a[ 3 ] ); return 0; /* indicates successful termination */ } /* end main */ 48 fig06_13.c (Part 2 of 3) 39
40 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 */ /* 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 m is %d\n" n", e *= 2 ); 68 } /* end function modifyelement */ fig06_13.c (Part 3 of 3) 40
41 Effects of passing entire array by reference: The values of the original array are: The values of the modified array are: Program Output 41 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 Notice that the original element remains unchanged!!!
42 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" n", a[ 0 ], a[ 1 ], a[ 2 ] ); return 0; /* indicates successful termination */ } /* end main */ 19 fig06_14.c (Part 1 of 2) 42
43 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 l specifies const object fig06_14.c(25) : error C2166: l-value l specifies const object fig06_14.c(26) : error C2166: l-value l specifies const object fig06_14.c (Part 2 of 2) Program Output 43 const definition causes the Compiler give errors!!
44 6.6 Sorting Arrays 44 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
45 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 i 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) 45
46 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 ements 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 fig06_15.c (Part 2 of 3) 46
47 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 47
48 6.7 Case Study: Computing Mean, Median and Mode Using Arrays Mean average Median number in middle of sorted list 1, 2, 3, 4, 5 3 is the median Mode number that occurs most often 1, 1, 1, 2, 3, 3, 4, 5 1 is the mode 48
49 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 fig06_16.c (Part 1 of 8) 49
50 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 */ 40 fig06_16.c (Part 2 of 8) 50
51 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%s n%s\n" 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" n" 57 "of data items ( %d ). The mean value for\n" 58 "this run is: %d / %d = %.4f\n\n" n", 59 SIZE, total, SIZE, ( double ) total / SIZE ); 60 } /* end function mean */ 61 fig06_16.c (Part 3 of 8) 51
52 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\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 nthe sorted array is" ); 74 printarray( answer ); /* output sorted array */ /* display median element */ 77 printf( "\n\nthe nthe median is element %d of\n" 78 "the sorted %d element array.\n" 79 "For this run the median is %d\n\n" n", 80 SIZE / 2, SIZE, answer[ SIZE / 2 ] ); 81 } /* end function median */ 82 fig06_16.c (Part 4 of 8) 52
53 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%s\n%s n%s\n" 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 fig06_16.c (Part 5 of 8) 53
54 105 /* output headers for result columns */ 106 printf( "%s%11s%19s\n\n%54s n%54s\n%54s n%54s\n\n" n", 107 "Response", "Frequency", "Histogram", 108 " ", " " ); /* 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 */ 127 fig06_16.c (Part 6 of 8) 54
55 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" 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 op 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 fig06_16.c (Part 7 of 8) 55
56 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) 56
57 ******** 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 57 ******** Median ******** The unsorted array of responses is The sorted array is
58 The median is element 49 of the sorted 99 element array. For this run the median is 7 ******** Mode ******** Response Frequency Histogram Program Output (continued) * 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. Histogram Scales 5, 10, 15, 20, 25
59 6.8 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 59
60 Linear search 60
61 6.8 Searching Arrays: Linear Search and Binary Search Binary search For sorted arrays 61 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
62 Binary search 62
63 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) 63
64 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" n", element ); 31 } /* end e if */ 32 else { 33 printf( "Value not found\n" n" ); 34 } /* end else */ return 0; /* indicates successful termination */ } /* end main */ /* 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 */ /* loop through array */ 48 for ( n = 0; n < size; ++n ) { 49 fig06_18.c (Part 2 of 3) 64
65 50 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 fig06_18.c (Part 3 of 3) Program Output 65 Enter integer search key: 37 Value not found
66 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) 66
67 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" n", key, result ); 35 } /* end if */ 36 else { 37 printf( "\n%d not found\n" 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 fig06_19.c (Part 2 of 5) 67
68 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 ray 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) 68
69 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: nsubscripts:\n" 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 fig06_19.c (Part 4 of 5) 69
70 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 */ /* 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 */ } /* end for */ printf( "\n" ); /* start new line of output */ 124 } /* end function printrow */ fig06_19.c (Part 5 of 5) 70
71 Enter a number between 0 and 28: 25 Subscripts: * * * 28 24* Program Output not found Enter a number between 0 and 28: 8 Subscripts: * * * 12 8* 8 found in array element 4
72 Enter a number between 0 and 28: 6 Subscripts: * * Program Output (continued) 72 6 found in array element 3
73 6.9 Multiple-Subscripted Arrays 73 Multiple subscripted arrays Tables with rows and columns (m by n array) Like matrices: specify row, then column Row 0 Row 1 Row 2 Column a[0][0] 0 a[1][0] a[2][0] Column 1 a[0][1] a[1][1] a[2][1] Column a[0][2] 2 a[1][2] a[2][2] Column 3 a[0][3] a[1][3] a[2][3] Array name Row subscript Column subscript
74 Multiple-Subscripted Arrays Initialization 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 ] );
75 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
76 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: fig06_21.c (Part 2 of 2) Program Output 76
77 #include <stdio.h> #include <stdlib.h> Example: Adding Two Matrices 77 int main() { int a[2][2] = {{10, 15}, {20, 5}}; /* Matrix a */ int b[2][2] = {{25, 5}, { 6, 0}}; /* Matrix b */ int c[2][2]; /* Matrix c */ int i, j; printf ("RESULTING ADDITION MATRIX \n\n"); for(i=0; i<2; i++) { for(j=0; j<2; j++) { c[i][j] = a[i][j] + b[i][j]; printf ("%d\t", c[i][j]); } printf ("\n"); /* new line */ } } system("pause"); return 0;
78 78 Example: Adding Two Matrices (Output) RESULTING ADDITION MATRIX Devam etmek için bir tuşa basın...
79 Example: Multiplying Two Matrices (1) The product of two nxn matrices X and Y is a third nxn matrix Z = X.Y, with (i,j) th entry 79 Z ij = N k = 1 X ik Y kj
80 Example: Multiplying Two Matrices (2) Example: X and Y are two 2x2 matrices. Z is also a 2x2 matrix (Z = X. Y) 80
81 Example: Multiplying Two Matrices (3) #include <stdio.h> #include <stdlib.h> #define N 2 #define M 4 #define L 3 81 int main() { int a[n][m] = {{8, 5, -6, 7}, {0, 2, 1, 4} }; /* Matrix a */ int b[m][l] = {{3, -9, 1}, {2, 5, 8}, {-2, 4, 0}, {1, 7, 6} }; /* Matrix b */ int c[n][l]; /* Matrix c */ int i,j,k;
82 Example: Multiplying Two Matrices (4) 82 /* First, compute he multiplication */ for (i = 0; i < N; i++) { for (j = 0; j < L; j++) { c[i][j] = 0; for (k = 0; k < M; k++) c[i][j] = c[i][j] + a[i][k] * b[k][j]; } }
83 Example: Multiplying Two Matrices (5) 83 /* Now, display the resulting matrix */ printf ("RESULTING MULTIPLICATION MATRIX \n\n"); for(i=0; i<n; i++) { for(j=0; j<l; j++) printf ("%d\t", c[i][j]); } printf ("\n"); /* new line */ } system("pause"); return 0;
84 84 Example: Multiplying Two Matrices (Output) RESULTING MULTIPLICATION MATRIX Devam etmek için bir tuşa basın...
85 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 m 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 fig06_22.c (Part 1 of 6) 85
86 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 nlowest grade: %d\nhighest grade: %d\n"% 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" n", 36 student, average( studentgrades[ student ], EXAMS ) ); 37 } /* end for */ return 0; /* indicates successful termination */ } /* end main */ /* 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 p grade */ 49 fig06_22.c (Part 2 of 6) 86
87 50 /* 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 */ /* 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 */ 74 fig06_22.c (Part 3 of 6) 87
88 75 /* 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 */ /* 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 */ 98 fig06_22.c (Part 4 of 6) 88
89 99 /* 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 */ /* 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 ); 122 fig06_22.c (Part 5 of 6) 89
90 123 /* output grades for one student */ 124 for ( j = 0; j < tests; j++ ) { 125 printf( "%-5d" 5d", grades[ i ][ j ] ); 126 } /* end inner for */ } /* end outer for */ } /* end function printarray */ fig06_22.c (Part 6 of 6) 90 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
C Arrays Pearson Education, Inc. All rights reserved.
1 6 C Arrays 2 Now go, write it before them in a table, and note it in a book. Isaiah 30:8 To go beyond is as wrong as to fall short. Confucius Begin at the beginning, and go on till you come to the end:
More informationC: How to Program. Week /Apr/23
C: How to Program Week 9 2007/Apr/23 1 Review of Chapters 1~5 Chapter 1: Basic Concepts on Computer and Programming Chapter 2: printf and scanf (Relational Operators) keywords Chapter 3: if (if else )
More informationC Arrays. Group of consecutive memory locations Same name and type. Array name + position number. Array elements are like normal variables
1 6 C Arrays 6.2 Arrays 2 Array Group of consecutive memory locations Same name and type To refer to an element, specify Array name + position number arrayname[ position number ] First element at position
More informationChapter 4 - Arrays. 4.1 Introduction. Arrays Structures of related data items Static entity (same size throughout program)
Chapter - Arrays 1.1 Introduction 2.1 Introduction.2 Arrays.3 Declaring Arrays. Examples Using Arrays.5 Passing Arrays to Functions.6 Sorting Arrays. Case Study: Computing Mean, Median and Mode Using Arrays.8
More informationChapter 4 - Arrays. 4.1 Introduction. Arrays Structures of related data items Static entity (same size throughout program) A few types
Chapter 4 - Arrays 1 4.1 Introduction 4.2 Arrays 4.3 Declaring Arrays 4.4 Examples Using Arrays 4.5 Passing Arrays to Functions 4.6 Sorting Arrays 4.7 Case Study: Computing Mean, Median and Mode Using
More informationOutline Introduction Arrays Declaring Arrays Examples Using Arrays Passing Arrays to Functions Sorting Arrays
Arrays Outline 1 Introduction 2 Arrays 3 Declaring Arrays 4 Examples Using Arrays 5 Passing Arrays to Functions 6 Sorting Arrays 7 Case Study: Computing Mean, Median and Mode Using Arrays 8 Searching Arrays
More informationC++ PROGRAMMING SKILLS Part 4: Arrays
C++ PROGRAMMING SKILLS Part 4: Arrays Outline Introduction to Arrays Declaring and Initializing Arrays Examples Using Arrays Sorting Arrays: Bubble Sort Passing Arrays to Functions Computing Mean, Median
More informationC: How to Program. Week /Apr/16
C: How to Program Week 8 2006/Apr/16 1 Storage class specifiers 5.11 Storage Classes Storage duration how long an object exists in memory Scope where object can be referenced in program Linkage specifies
More informationComputer Programming Lecture 14 Arrays (Part 2)
Computer Programming Lecture 14 Arrays (Part 2) Assist.Prof.Dr. Nükhet ÖZBEK Ege University Department of Electrical & Electronics Engineering nukhet.ozbek@ege.edu.tr 1 Topics The relationship between
More informationCHAPTER 3 ARRAYS. Dr. Shady Yehia Elmashad
CHAPTER 3 ARRAYS Dr. Shady Yehia Elmashad Outline 1. Introduction 2. Arrays 3. Declaring Arrays 4. Examples Using Arrays 5. Multidimensional Arrays 6. Multidimensional Arrays Examples 7. Examples Using
More informationArray. Arrays. Declaring Arrays. Using Arrays
Arrays CS215 Peter Lo 2004 1 Array Array Group of consecutive memory locations Same name and type To refer to an element, specify Array name Position number Format: arrayname[ position number] First element
More informationArrays. Systems Programming Concepts
Arrays Systems Programming Concepts Arrays Arrays Defining and Initializing Arrays Array Example Subscript Out-of-Range Example Passing Arrays to Functions Call by Reference Multiple-Subscripted Arrays
More informationC How to Program, 7/e by Pearson Education, Inc. All Rights Reserved.
C How to Program, 7/e This chapter serves as an introduction to data structures. Arrays are data structures consisting of related data items of the same type. In Chapter 10, we discuss C s notion of
More informationLecture 04 FUNCTIONS AND ARRAYS
Lecture 04 FUNCTIONS AND ARRAYS 1 Motivations Divide hug tasks to blocks: divide programs up into sets of cooperating functions. Define new functions with function calls and parameter passing. Use functions
More informationArrays. Outline. Multidimensional Arrays Case Study: Computing Mean, Median and Mode Using Arrays Prentice Hall, Inc. All rights reserved.
Arrays 1 Multidimensional Arrays Case Study: Computing Mean, Median and Mode Using Arrays Multidimensional Arrays 2 Multiple subscripts a[ i ][ j ] Tables with rows and columns Specify row, then column
More informationContent. In this chapter, you will learn:
ARRAYS & HEAP Content In this chapter, you will learn: To introduce the array data structure To understand the use of arrays To understand how to define an array, initialize an array and refer to individual
More informationArrays. Week 4. Assylbek Jumagaliyev
Arrays Week 4 Assylbek Jumagaliyev a.jumagaliyev@iitu.kz Introduction Arrays Structures of related data items Static entity (same size throughout program) A few types Pointer-based arrays (C-like) Arrays
More informationC Arrays. O b j e c t i v e s In this chapter, you ll:
www.thestudycampus.com C Arrays O b j e c t i v e s In this chapter, you ll: Use the array data structure to represent lists and tables of values. Define an array, initialize an array and refer to individual
More informationKingdom of Saudi Arabia Princes Nora bint Abdul Rahman University College of Computer Since and Information System CS242 ARRAYS
Kingdom of Saudi Arabia Princes Nora bint Abdul Rahman University College of Computer Since and Information System CS242 1 ARRAYS Arrays 2 Arrays Structures of related data items Static entity (same size
More informationArrays and Applications
Arrays and Applications 60-141: Introduction to Algorithms and Programming II School of Computer Science Term: Summer 2014 Instructor: Dr. Asish Mukhopadhyay What s an array Let a 0, a 1,, a n-1 be a sequence
More informationBBS 514 YAPISAL PROGRAMLAMA (STRUCTURED PROGRAMMING)
1 BBS 514 YAPISAL PROGRAMLAMA (STRUCTURED PROGRAMMING) 6 LECTURE 7: ARRAYS Lecturer: Burcu Can BBS 514 - Yapısal Programlama (Structured Programming) Arrays (Diziler) Array (Dizi) Group of consecutive
More informationProgramming for Engineers Arrays
Programming for Engineers Arrays ICEN 200 Spring 2018 Prof. Dola Saha 1 Array Ø Arrays are data structures consisting of related data items of the same type. Ø A group of contiguous memory locations that
More informationMultiple-Subscripted Arrays
Arrays in C can have multiple subscripts. A common use of multiple-subscripted arrays (also called multidimensional arrays) is to represent tables of values consisting of information arranged in rows and
More informationChapter 5 - Functions
Chapter 5 - Functions! 0 6 ;: > E 5J7J 5J 5J! 5J #"%$& ' ( )+*, -. / * - # * - # 213 45 * - # 7 )98 < = *?' )A@B?' )+C 4; D - C/ =(GF 'H I D. K D L M N& K - (8 C C -( O C -( O P7 7Q R S+T?U V&WAXZY\[^]`_bacXde[fW
More informationTwo Dimensional Array - An array with a multiple indexs.
LAB5 : Arrays Objectives: 1. To learn how to use C array as a counter. 2. To learn how to add an element to the array. 3. To learn how to delete an element from the array. 4. To learn how to declare two
More informationArrays Introduction. Group of contiguous memory locations. Each memory location has same name Each memory location has same type
Array Arrays Introduction Group of contiguous memory locations Each memory location has same name Each memory location has same type Remain same size once created Static entries 1 Name of array (Note that
More informationC How to Program, 6/e by Pearson Education, Inc. All Rights Reserved.
C How to Program, 6/e 1992-2010 by Pearson Education, Inc. 1992-2010 by Pearson Education, Inc. 1992-2010 by Pearson Education, Inc. This chapter serves as an introduction to the important topic of data
More informationTwo Dimensional Array - An array with a multiple indexs.
LAB5 : Arrays Objectives: 1. To learn how to use C array as a counter. 2. To learn how to add an element to the array. 3. To learn how to delete an element from the array. 4. To learn how to declare two
More informationOutline Arrays Examples of array usage Passing arrays to functions 2D arrays Strings Searching arrays Next Time. C Arrays.
CS 2060 Week 5 1 Arrays Arrays Initializing arrays 2 Examples of array usage 3 Passing arrays to functions 4 2D arrays 2D arrays 5 Strings Using character arrays to store and manipulate strings 6 Searching
More informationCSE101-Lec#17. Arrays. (Arrays and Functions) Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU. LPU CSE101 C Programming
Arrays CSE101-Lec#17 (Arrays and Functions) Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU Outline To declare an array To initialize an array To pass an array to a function Arrays Introduction
More informationChapter 7 Array. Array. C++, How to Program
Chapter 7 Array C++, How to Program Deitel & Deitel Spring 2016 CISC 1600 Yanjun Li 1 Array Arrays are data structures containing related data items of same type. An array is a consecutive group of memory
More informationYacoub Sabatin Muntaser Abulafi Omar Qaraeen
Programming Fundamentals for Engineers - 0702113 6. Arrays Yacoub Sabatin Muntaser Abulafi Omar Qaraeen 1 One-Dimensional Arrays There are times when we need to store a complete list of numbers or other
More informationChapter 7. Pointers. Copyright 2007 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
1 Chapter 7 Pointers Copyright 2007 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. 2 Chapter 7 - Pointers 7.1 Introduction 7.2 Pointer Variable Definitions and Initialization
More informationONE DIMENSIONAL ARRAYS
LECTURE 14 ONE DIMENSIONAL ARRAYS Array : An array is a fixed sized sequenced collection of related data items of same data type. In its simplest form an array can be used to represent a list of numbers
More informationObjectivities. Experiment 1. Lab6 Array I. Description of the Problem. Problem-Solving Tips
Lab6 Array I Objectivities 1. Using rand to generate random numbers and using srand to seed the random-number generator. 2. Declaring, initializing and referencing arrays. 3. The follow-up questions and
More informationLecture 2 Arrays, Searching and Sorting (Arrays, multi-dimensional Arrays)
Lecture 2 Arrays, Searching and Sorting (Arrays, multi-dimensional Arrays) In this lecture, you will: Learn about arrays Explore how to declare and manipulate data into arrays Understand the meaning of
More informationPointers. Chih-Wei Tang ( 唐之瑋 ) Department of Communication Engineering National Central University JhongLi, Taiwan
Pointers Chih-Wei Tang ( 唐之瑋 ) Department of Communication Engineering National Central University JhongLi, Taiwan Outline 7.1 Introduction 7.2 Pointer Variable Definitions and Initialization 7.3 Pointer
More informationComputer Science & Engineering 150A Problem Solving Using Computers
Computer Science & Engineering 150A Problem Solving Using Computers Lecture 06 - Stephen Scott Adapted from Christopher M. Bourke 1 / 30 Fall 2009 Chapter 8 8.1 Declaring and 8.2 Array Subscripts 8.3 Using
More informationChapter 6 - Pointers
Chapter 6 - Pointers Outline 1 Introduction 2 Pointer Variable Declarations and Initialization 3 Pointer Operators 4 Calling Functions by Reference 5 Using the const Qualifier with Pointers 6 Bubble Sort
More informationCSE101-Lec#18. Multidimensional Arrays Application of arrays. Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU. LPU CSE101 C Programming
CSE101-Lec#18 Multidimensional Arrays Application of arrays Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU Outline Defining and processing 1D array 2D array Applications of arrays 1-D array A
More informationFundamental of Programming (C)
Borrowed from lecturer notes by Omid Jafarinezhad Fundamental of Programming (C) Lecturer: Vahid Khodabakhshi Lecture 8 Array typical problems, Search, Sorting Department of Computer Engineering Outline
More informationOutline. Computer Memory Structure Addressing Concept Introduction to Pointer Pointer Manipulation Summary
Pointers 1 2 Outline Computer Memory Structure Addressing Concept Introduction to Pointer Pointer Manipulation Summary 3 Computer Memory Revisited Computers store data in memory slots Each slot has an
More informationC Pointers Pearson Education, Inc. All rights reserved.
1 7 C Pointers 2 Addresses are given to us to conceal our whereabouts. Saki (H. H. Munro) By indirection find direction out. William Shakespeare Many things, having full reference To one consent, may work
More informationC Pointers. sizeof Returns size of operand in bytes For arrays: size of 1 element * number of elements if sizeof( int ) equals 4 bytes, then
1 7 C Pointers 7.7 sizeof Operator 2 sizeof Returns size of operand in bytes For arrays: size of 1 element * number of elements if sizeof( int ) equals 4 bytes, then int myarray[ 10 ]; printf( "%d", sizeof(
More informationITC213: STRUCTURED PROGRAMMING. Bhaskar Shrestha National College of Computer Studies Tribhuvan University
ITC213: STRUCTURED PROGRAMMING Bhaskar Shrestha National College of Computer Studies Tribhuvan University Lecture 10: Arrays Readings: Chapter 9 Introduction Group of same type of variables that have same
More informationObjectives of This Chapter
Chapter 6 C Arrays Objectives of This Chapter Array data structures to represent the set of values. Defining and initializing arrays. Defining symbolic constant in a program. Using arrays to store, list,
More informationC Pointers. 7.2 Pointer Variable Definitions and Initialization
1 7 C Pointers 7.2 Pointer Variable Definitions and Initialization Pointer variables Contain memory addresses as their values Normal variables contain a specific value (direct reference) Pointers contain
More informationC Functions. 5.2 Program Modules in C
1 5 C Functions 5.2 Program Modules in C 2 Functions Modules in C Programs combine user-defined functions with library functions - C standard library has a wide variety of functions Function calls Invoking
More informationOutline. 7.1 Introduction. 7.2 Arrays. 7.2 Arrays
jhtp5_07.fm Page 279 Wednesday, November 20, 2002 12:44 PM 7 Arrays Objectives To introduce the array data structure. To understand the use of arrays to store, sort and search lists and tables of values.
More informationSolutions to Chapter 8
Solutions to Chapter 8 Review Questions 1. a. True 3. b. False 5. b. False 7. c. index 9. d. ary[0] = x; 11. e. sorting 13. e. sequential 15. a. A two-dimensional array can be thought of as an array of
More informationPrinciples of Programming. Chapter 6: Arrays
Chapter 6: Arrays In this chapter, you will learn about Introduction to Array Array declaration Array initialization Assigning values to array elements Reading values from array elements Simple Searching
More informationFundamentals of Programming Session 15
Fundamentals of Programming Session 15 Instructor: Reza Entezari-Maleki Email: entezari@ce.sharif.edu 1 Fall 2013 These slides have been created using Deitel s slides Sharif University of Technology Outlines
More informationIntroduction to Computer Science Midterm 3 Fall, Points
Introduction to Computer Science Fall, 2001 100 Points Notes 1. Tear off this sheet and use it to keep your answers covered at all times. 2. Turn the exam over and write your name next to the staple. Do
More informationFundamental of Programming (C)
Borrowed from lecturer notes by Omid Jafarinezhad Fundamental of Programming (C) Lecturer: Vahid Khodabakhshi Lecture 3 Constants, Variables, Data Types, And Operations Department of Computer Engineering
More informationC Language Part 2 Digital Computer Concept and Practice Copyright 2012 by Jaejin Lee
C Language Part 2 (Minor modifications by the instructor) 1 Scope Rules A variable declared inside a function is a local variable Each local variable in a function comes into existence when the function
More informationDr M Kasim A Jalil. Faculty of Mechanical Engineering UTM (source: Deitel Associates & Pearson)
Lecture 9 Functions Dr M Kasim A Jalil Faculty of Mechanical Engineering UTM (source: Deitel Associates & Pearson) Objectives In this chapter, you will learn: To understand how to construct programs modularly
More informationProcedural Programming
Universität Duisburg-Essen PRACTICAL TRAINING TO THE LECTURE Procedural Programming Session Five: Arrays Name: First Name: Tutor: Matriculation-Number: Group-Number: Date: Prof. Dr.Ing. Axel Hunger Dipl.-Ing.
More informationTo declare an array in C, a programmer specifies the type of the elements and the number of elements required by an array as follows
Unti 4: C Arrays Arrays a kind of data structure that can store a fixed-size sequential collection of elements of the same type An array is used to store a collection of data, but it is often more useful
More informationby Pearson Education, Inc. All Rights Reserved. 2
Two ways to pass arguments to functions in many programming languages are pass-by-value and pass-by-reference. When an argument is passed by value, a copy of the argument s value is made and passed (on
More informationC Programming Language
C Programming Language Arrays & Pointers I Dr. Manar Mohaisen Office: F208 Email: manar.subhi@kut.ac.kr Department of EECE Review of Precedent Class Explain How to Create Simple Functions Department of
More informationIntroduction to C Final Review Chapters 1-6 & 13
Introduction to C Final Review Chapters 1-6 & 13 Variables (Lecture Notes 2) Identifiers You must always define an identifier for a variable Declare and define variables before they are called in an expression
More informationChapter 3 Structured Program Development
1 Chapter 3 Structured Program Development Copyright 2007 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. Chapter 3 - Structured Program Development Outline 3.1 Introduction
More informationGovernment Polytechnic Muzaffarpur.
Government Polytechnic Muzaffarpur. Name of the Lab: COMPUTER PROGRAMMING LAB (MECH. ENGG. GROUP) Subject Code: 1625408 Experiment: 1 Aim: Programming exercise on executing a C program. If you are looking
More informationFunctions. Computer System and programming in C Prentice Hall, Inc. All rights reserved.
Functions In general, functions are blocks of code that perform a number of pre-defined commands to accomplish something productive. You can either use the built-in library functions or you can create
More informationCSCE 110 PROGRAMMING FUNDAMENTALS. Prof. Amr Goneid AUC Part 7. 1-D & 2-D Arrays
CSCE 110 PROGRAMMING FUNDAMENTALS WITH C++ Prof. Amr Goneid AUC Part 7. 1-D & 2-D Arrays Prof. Amr Goneid, AUC 1 Arrays Prof. Amr Goneid, AUC 2 1-D Arrays Data Structures The Array Data Type How to Declare
More informationCSE101-lec#19. Array searching and sorting techniques. Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU. LPU CSE101 C Programming
CSE101-lec#19 Array searching and sorting techniques Created By: Amanpreet Kaur & Sanjeev Kumar SME (CSE) LPU Outline Introduction Linear search Binary search Bubble sort Introduction The process of finding
More informationFundamentals of Programming Session 14
Fundamentals of Programming Session 14 Instructor: Reza Entezari-Maleki Email: entezari@ce.sharif.edu 1 Fall 2013 These slides have been created using Deitel s slides Sharif University of Technology Outlines
More informationArrays a kind of data structure that can store a fixedsize sequential collection of elements of the same type. An array is used to store a collection
Morteza Noferesti Arrays a kind of data structure that can store a fixedsize sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful
More informationMaltepe University Computer Engineering Department. BİL 133 Algorithms and Programming. Chapter 8: Arrays
Maltepe University Computer Engineering Department BİL 133 Algorithms and Programming Chapter 8: Arrays What is an Array? Scalar data types use a single memory cell to store a single value. For many problems
More informationMaltepe University Computer Engineering Department. BİL 133 Algoritma ve Programlama. Chapter 8: Arrays and pointers
Maltepe University Computer Engineering Department BİL 133 Algoritma ve Programlama Chapter 8: Arrays and pointers Basics int * ptr1, * ptr2; int a[10]; ptr1 = &a[2]; ptr2 = a; // equivalent to ptr2 =
More informationInstructor: Eng.Omar Al-Nahal
Faculty of Engineering & Information Technology Software Engineering Department Computer Science [2] Lab 6: Introduction in arrays Declaring and Creating Arrays Multidimensional Arrays Instructor: Eng.Omar
More informationComputer Programming. C Array is a collection of data belongings to the same data type. data_type array_name[array_size];
Arrays An array is a collection of two or more adjacent memory cells, called array elements. Array is derived data type that is used to represent collection of data items. C Array is a collection of data
More informationArrays (Deitel chapter 7)
Arrays (Deitel chapter 7) Plan Arrays Declaring and Creating Arrays Examples Using Arrays References and Reference Parameters Passing Arrays to Methods Sorting Arrays Searching Arrays: Linear Search and
More informationAN OVERVIEW OF C, PART 3. CSE 130: Introduction to Programming in C Stony Brook University
AN OVERVIEW OF C, PART 3 CSE 130: Introduction to Programming in C Stony Brook University FANCIER OUTPUT FORMATTING Recall that you can insert a text field width value into a printf() format specifier:
More informationFunctions. Angela Chih-Wei Tang ( 唐之瑋 ) Department of Communication Engineering National Central University JhongLi, Taiwan.
Functions Angela Chih-Wei Tang ( 唐之瑋 ) Department of Communication Engineering National Central University JhongLi, Taiwan 2009 Fall Outline 5.1 Introduction 5.3 Math Library Functions 5.4 Functions 5.5
More informationKOM3191 Object Oriented Programming Dr Muharrem Mercimek ARRAYS ~ VECTORS. KOM3191 Object-Oriented Computer Programming
KOM3191 Object Oriented Programming Dr Muharrem Mercimek 1 ARRAYS ~ VECTORS KOM3191 Object-Oriented Computer Programming KOM3191 Object Oriented Programming Dr Muharrem Mercimek 2 What is an array? Arrays
More informationCSE123. Program Design and Modular Programming Functions 1-1
CSE123 Program Design and Modular Programming Functions 1-1 5.1 Introduction A function in C is a small sub-program performs a particular task, supports the concept of modular programming design techniques.
More informationChapter 6 Arrays and Strings Prentice Hall, Inc. All rights reserved.
1 Chapter 6 Arrays and Strings Introduction 2 Arrays Data structures Related data items of same type Reference type Remain same size once created Fixed-length entries 3 Name of array (note that all elements
More informationChapter 8 Arrays and Strings. Objectives. Objectives (cont d.) Introduction. Arrays 12/23/2016. In this chapter, you will:
Chapter 8 Arrays and Strings Objectives In this chapter, you will: Learn about arrays Declare and manipulate data into arrays Learn about array index out of bounds Learn about the restrictions on array
More informationArrays. Arrays are of 3 types One dimensional array Two dimensional array Multidimensional array
Arrays Array is a collection of similar data types sharing same name or Array is a collection of related data items. Array is a derived data type. Char, float, int etc are fundamental data types used in
More informationHigh Institute of Computer Science & Information Technology Term : 1 st. El-Shorouk Academy Acad. Year : 2013 / Year : 2 nd
El-Shorouk Academy Acad. Year : 2013 / 2014 High Institute of Computer Science & Information Technology Term : 1 st Year : 2 nd Computer Science Department Object Oriented Programming Section (1) Arrays
More informationIS 0020 Program Design and Software Tools
1 Program Components in C++ 2 IS 0020 Program Design and Software Tools Introduction to C++ Programming Lecture 2 Functions and Arrays Jan 13, 200 Modules: functionsand classes Programs use new and prepackaged
More informationA First Book of ANSI C Fourth Edition. Chapter 8 Arrays
A First Book of ANSI C Fourth Edition Chapter 8 Arrays Objectives One-Dimensional Arrays Array Initialization Arrays as Function Arguments Case Study: Computing Averages and Standard Deviations Two-Dimensional
More informationProgramming Assignment #4 Arrays and Pointers
CS-2301, System Programming for Non-majors, B-term 2013 Project 4 (30 points) Assigned: Tuesday, November 19, 2013 Due: Tuesday, November 26, Noon Abstract Programming Assignment #4 Arrays and Pointers
More informationC++ Programming. Arrays and Vectors. Chapter 6. Objectives. Chiou. This chapter introduces the important topic of data structures collections
C++ Programming Chapter 6 Arrays and Vectors Yih-Peng Chiou Room 617, BL Building (02) 3366-3603 3603 ypchiou@cc.ee.ntu.edu.tw Photonic Modeling and Design Lab. Graduate Institute of Photonics and Optoelectronics
More informationChapter 3: Arrays and More C Functionality
Chapter 3: Arrays and More C Functionality Objectives: (a) Describe how an array is stored in memory. (b) Define a string, and describe how strings are stored. (c) Describe the implications of reading
More informationUnit 3 Decision making, Looping and Arrays
Unit 3 Decision making, Looping and Arrays Decision Making During programming, we have a number of situations where we may have to change the order of execution of statements based on certain conditions.
More informationCSE 2421: Systems I Low-Level Programming and Computer Organization. Functions. Presentation C. Predefined Functions
CSE 2421: Systems I Low-Level Programming and Computer Organization Functions Read/Study: Reek Chapters 7 Gojko Babić 01-22-2018 Predefined Functions C comes with libraries of predefined functions E.g.:
More informationECE264 Fall 2013 Exam 1, September 24, 2013
ECE264 Fall 2013 Exam 1, September 24, 2013 In signing this statement, I hereby certify that the work on this exam is my own and that I have not copied the work of any other student while completing it.
More informationFunctions. Systems Programming Concepts
Functions Systems Programming Concepts Functions Simple Function Example Function Prototype and Declaration Math Library Functions Function Definition Header Files Random Number Generator Call by Value
More informationBITG 1113: Array (Part 1) LECTURE 8
BITG 1113: Array (Part 1) LECTURE 8 1 1 LEARNING OUTCOMES At the end of this lecture, you should be able to: 1. Describe the fundamentals of arrays 2. Describe the types of array: One Dimensional (1 D)
More informationAn array is a collection of data that holds fixed number of values of same type. It is also known as a set. An array is a data type.
Data Structures Introduction An array is a collection of data that holds fixed number of values of same type. It is also known as a set. An array is a data type. Representation of a large number of homogeneous
More information6-1 (Function). (Function) !*+!"#!, Function Description Example. natural logarithm of x (base e) rounds x to smallest integer not less than x
(Function) -1.1 Math Library Function!"#! $%&!'(#) preprocessor directive #include !*+!"#!, Function Description Example sqrt(x) square root of x sqrt(900.0) is 30.0 sqrt(9.0) is 3.0 exp(x) log(x)
More informationHow to declare an array in C?
Introduction An array is a collection of data that holds fixed number of values of same type. It is also known as a set. An array is a data type. Representation of a large number of homogeneous values.
More informationCS 261 Data Structures. Big-Oh Analysis: A Review
CS 261 Data Structures Big-Oh Analysis: A Review Big-Oh: Purpose How can we characterize the runtime or space usage of an algorithm? We want a method that: doesn t depend upon hardware used (e.g., PC,
More informationC: How to Program. Week /Mar/05
1 C: How to Program Week 2 2007/Mar/05 Chapter 2 - Introduction to C Programming 2 Outline 2.1 Introduction 2.2 A Simple C Program: Printing a Line of Text 2.3 Another Simple C Program: Adding Two Integers
More informationcalling a function - function-name(argument list); y = square ( z ); include parentheses even if parameter list is empty!
Chapter 6 - Functions return type void or a valid data type ( int, double, char, etc) name parameter list void or a list of parameters separated by commas body return keyword required if function returns
More informationby Pearson Education, Inc. All Rights Reserved.
Let s improve the bubble sort program of Fig. 6.15 to use two functions bubblesort and swap. Function bubblesort sorts the array. It calls function swap (line 51) to exchange the array elements array[j]
More informationThe C language. Introductory course #1
The C language Introductory course #1 History of C Born at AT&T Bell Laboratory of USA in 1972. Written by Dennis Ritchie C language was created for designing the UNIX operating system Quickly adopted
More informationUIC. C Programming Primer. Bharathidasan University
C Programming Primer UIC C Programming Primer Bharathidasan University Contents Getting Started 02 Basic Concepts. 02 Variables, Data types and Constants...03 Control Statements and Loops 05 Expressions
More information