1

6.6 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: 3 4 2 6 7
– pass 1: 3 2 4 6 7
– pass 2: 2 3 4 6 7
– Small elements "bubble" to the top
1 /* Fig. 6.15: fig06_15.c 2
2 This program sorts an array's values into ascending order */
3 #include <stdio.h>
4 #define SIZE 10
5
6 /* function main begins program execution */
7 int main( void )
8 {
9 /* initialize a */
10 int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
11 int pass; /* passes counter */
12 int i; /* comparisons counter */
13 int hold; /* temporary location used to swap array elements */
14
15 printf( "Data items in original order\n" );
16
17 /* output original array */
18 for ( i = 0; i < SIZE; i++ ) {
19 printf( "%4d", a[ i ] );
20 } /* end for */
21
22 /* bubble sort */
23 /* loop to control number of passes */
24 for ( pass = 1; pass < SIZE; pass++ ) {
25
26 /* loop to control number of comparisons per pass */
27 for ( i = 0; i < SIZE - 1; i++ ) {
28
29 /* compare adjacent elements and swap them if first 3
30 element is greater than second element */
31 if ( a[ i ] > a[ i + 1 ] ) {
32 hold = a[ i ];
33 a[ i ] = a[ i + 1 ]; If any two array elements are out of
34 a[ i + 1 ] = hold; order, the function swaps them
35 } /* end if */
36
37 } /* end inner for */
38
39 } /* end outer for */
40
41 printf( "\nData items in ascending order\n" );
42
43 /* output sorted array */
44 for ( i = 0; i < SIZE; i++ ) {
45 printf( "%4d", a[ i ] );
46 } /* end for */
47
48 printf( "\n" );
49
50 return 0; /* indicates successful termination */
51 }

Data items in original order

2 6 4 8 10 12 89 68 45 37
Data items in ascending order
2 4 6 8 10 12 37 45 68 89
 4

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
1 /* Fig. 6.16: fig06_16.c 5
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 99
6
7 /* 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[] );
13
14 /* function main begins program execution */
15 int main( void )
16 {
17 int frequency[ 10 ] = { 0 }; /* initialize array frequency */
18
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 };
31 6
32 /* process responses */
33 mean( response );
34 median( response );
35 mode( frequency, response );
36
37 return 0; /* indicates successful termination */
38
39 } /* end main */
40
41 /* calculate average of all response values */
42 void mean( const int answer[] )
43 {
44 int j; /* counter for totaling array elements */
45 int total = 0; /* variable to hold sum of array elements */
46
47 printf( "%s\n%s\n%s\n", "********", " Mean", "********" );
48
49 /* total response values */
50 for ( j = 0; j < SIZE; j++ ) {
51 total += answer[ j ];
52 } /* end for */
53
54 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 7
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" );
68
69 printArray( answer ); /* output unsorted array */
70
71 bubbleSort( answer ); /* sort array */ Once the array is sorted, the median will be
72
the value of the middle element
73 printf( "\n\nThe sorted array is" );
74 printArray( answer ); /* output sorted array */
75
76 /* 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
83 /* determine most frequent response */
84 void mode( int freq[], const int answer[] )
85 {
86 int rating; /* counter for accessing elements 1-9 of array freq */
87 int j; /* counter for summarizing elements 0-98 of array answer */
88 int h; /* counter for diplaying histograms of elements in array freq */
89 int largest = 0; /* represents largest frequency */
90 int modeValue = 0; /* represents most frequent response */
91 8
92 printf( "\n%s\n%s\n%s\n",
93 "********", " Mode", "********" );
94
95 /* initialize frequencies to 0 */
96 for ( rating = 1; rating <= 9; rating++ ) {
97 freq[ rating ] = 0;
98 } /* end for */
99
100 /* summarize frequencies */
101 for ( j = 0; j < SIZE; j++ ) {
102 ++freq[ answer[ j ] ];
103 } /* end for */
104
105 /* output headers for result columns */
106 printf( "%s%11s%19s\n\n%54s\n%54s\n\n",
107 "Response", "Frequency", "Histogram",
108 "1 1 2 2", "5 0 5 0 5" );
109
110 /* output results */
111 for ( rating = 1; rating <= 9; rating++ ) {
112 printf( "%8d%11d ", rating, freq[ rating ] );
113
114 /* keep track of mode value and largest frequency value */
115 if ( freq[ rating ] > largest ) {
116 largest = freq[ rating ];
117 modeValue = rating;
118 } /* end if */
119 9
120 /* output histogram bar representing frequency value */
121 for ( h = 1; h <= freq[ rating ]; h++ ) {
122 printf( "*" );
123 } /* end inner for */
124
125 printf( "\n" ); /* being new line of output */
126 } /* end outer for */
127
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 */
133
134 /* function that sorts an array with bubble sort algorithm */
135 void bubbleSort( int a[] )
136 {
137 int pass; /* pass counter */
138 int j; /* comparison counter */
139 int hold; /* temporary location used to swap elements */
140
141 /* loop to control number of passes */
142 for ( pass = 1; pass < SIZE; pass++ ) {
143
144 /* loop to control number of comparisons per pass */
145 for ( j = 0; j < SIZE - 1; j++ ) {
146
147 /* swap elements if out of order */ 10
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
154 } /* end inner for */
155
156 } /* end outer for */
157
158 } /* end function bubbleSort */
159
160 /* output array contents (20 values per row) */
161 void printArray( const int a[] )
162 {
163 int j; /* counter */
164
165 /* output array contents */
166 for ( j = 0; j < SIZE; j++ ) {
167
168 if ( j % 20 == 0 ) { /* begin new line every 20 values */
169 printf( "\n" );
170 } /* end if */
171
172 printf( "%2d", a[ j ] );
173 } /* end for */
174
175 } /* end function printArray */
******** 11
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 = 6.8788

********
Median
********
The unsorted array of responses is
6 7 8 9 8 7 8 9 8 9 7 8 9 5 9 8 7 8 7 8
6 7 8 9 3 9 8 7 8 7 7 8 9 8 9 8 9 7 8 9
6 7 8 7 8 7 9 8 9 2 7 8 9 8 9 8 9 7 5 3
5 6 7 2 5 3 9 4 6 4 7 8 9 6 8 7 8 9 7 8
7 4 4 2 5 3 8 7 5 6 4 5 6 1 6 5 7 8 7

The sorted array is

1 2 2 2 3 3 3 3 4 4 4 4 4 5 5 5 5 5 5 5
5 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9
(continued on next slide… )
 (continued from previous slide…) 12
The median is element 49 of
the sorted 99 element array.
For this run the median is 7

********
Mode
********
Response Frequency Histogram

1 1 2 2
5 0 5 0 5

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.
 13

6.8 Searching Arrays

 Search an array for a key value
 Linear search
– Simple
– Compare each element of array with key value
– Useful for small and unsorted arrays
1 /* Fig. 6.18: fig06_18.c 14
2 Linear search of an array */
3 #include <stdio.h>
4 #define SIZE 100
5
6 /* function prototype */
7 int linearSearch( const int array[], int key, int size );
8
9 /* function main begins program execution */
10 int main( void )
11 {
12 int a[ SIZE ]; /* create array a */
13 int x; /* counter for initializing elements 0-99 of array a */
14 int searchKey; /* value to locate in array a */
15 int element; /* variable to hold location of searchKey or -1 */
16
17 /* create data */
18 for ( x = 0; x < SIZE; x++ ) {
19 a[ x ] = 2 * x;
20 } /* end for */
21
22 printf( "Enter integer search key:\n" ); 15
23 scanf( "%d", &searchKey );
24
25 /* attempt to locate searchKey in array a */
26 element = linearSearch( a, searchKey, SIZE );
27
28 /* 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 */
35
36 return 0; /* indicates successful termination */
37
38 } /* end main */
39
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 */
46
47 /* loop through array */ 16
48 for ( n = 0; n < size; ++n ) {
49
50 if ( array[ n ] == key ) {
51 return n; /* return location of key */
52 } /* end if */ Linear search algorithm searches
53 through every element in the
54 } /* end for */
array until a match is found
55
56 return -1; /* key not found */
57
58 } /* end function linearSearch */

Enter integer search key:

36
Found value in element 18

Enter integer search key:

37
Value not found
 17

6.8 Searching Arrays

 Binary search
– For sorted arrays only
– 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 2n > number of
elements
- 30 element array takes at most 5 steps
25 > 30 so at most 5 steps
1 /* Fig. 6.19: fig06_19.c 18
2 Binary search of an array */
3 #include <stdio.h>
4 #define SIZE 15
5
6 /* 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 );
10
11 /* function main begins program execution */
12 int main( void )
13 {
14 int a[ SIZE ]; /* create array a */
15 int i; /* counter for initializing elements 0-14 of array a */
16 int key; /* value to locate in array a */
17 int result; /* variable to hold location of key or -1 */
18
19 /* create data */
20 for ( i = 0; i < SIZE; i++ ) {
21 a[ i ] = 2 * i;
22 } /* end for */
23
24 printf( "Enter a number between 0 and 28: " );
25 scanf( "%d", &key );
26
27 printHeader();
28
29 /* search for key in array a */
30 result = binarySearch( a, key, 0, SIZE - 1 );
31 19
32 /* 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 */
39
40 return 0; /* indicates successful termination */
41
42 } /* end main */
43
44 /* 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
49 /* loop until low subscript is greater than high subscript */
50 while ( low <= high ) {
51
52 /* determine middle element of subarray being searched */
53 middle = ( low + high ) / 2;
54
55 /* display subarray used in this loop iteration */
56 printRow( b, low, middle, high );
57
58 /* if searchKey matched middle element, return middle */
59 if ( searchKey == b[ middle ] ) {
60 return middle;
If value is found, return its index
61 } /* end if */
62
63 /* 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 value is too high, search the left half of array
67
68 /* if searchKey greater than middle element, set new low */
69 else {
70 low = middle + 1; /* search high end of array */
71 } /* end else */
72 If value is too low, search the right half of array
73 } /* end while */
74
75 return -1; /* searchKey not found */
76
77 } /* end function binarySearch */
78
79 /* Print a header for the output */
80 void printHeader( void )
81 {
82 int i; /* counter */
83
84 printf( "\nSubscripts:\n" );
85
86 /* output column head */ 21
87 for ( i = 0; i < SIZE; i++ ) {
88 printf( "%3d ", i );
89 } /* end for */
90
91 printf( "\n" ); /* start new line of output */
92
93 /* output line of - characters */
94 for ( i = 1; i <= 4 * SIZE; i++ ) {
95 printf( "-" );
96 } /* end for */
97
98 printf( "\n" ); /* start new line of output */
99 } /* end function printHeader */
100
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 for iterating through array b */
106
107 /* loop through entire array */ 22
108 for ( i = 0; i < SIZE; i++ ) {
109
110 /* 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 */
120
121 } /* end for */
122
123 printf( "\n" ); /* start new line of output */
124 } /* end function printRow */

Enter a number between 0 and 28: 25

Subscripts:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
------------------------------------------------------------
0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28
16 18 20 22* 24 26 28
24 26* 28
24*

25 not found
(continued on next slide… )
 (continued from previous slide…)
Enter a number between 0 and 28: 8

Subscripts:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
------------------------------------------------------------
0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28
0 2 4 6* 8 10 12
8 10* 12
8*

8 found in array element 4

Enter a number between 0 and 28: 6

Subscripts:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
------------------------------------------------------------
0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28
0 2 4 6* 8 10 12

6 found in array element 3

 24

6.9 Multiple-Subscripted Arrays

 Multiple subscripted arrays
– Tables with rows and columns (m by n array)
– Like matrices: specify row, then column
 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 ] );
 25

Double-subscripted array with three rows and four columns.

1 /* Fig. 6.21: fig06_21.c 26
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( void )
9 {
10 /* initialize array1, array2, array3 */ array1 is initialized with both
11 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } }; rows full
12 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 };
13 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; array2 and array3 are initialized only
14 partially
15 printf( "Values in array1 by row are:\n" );
16 printArray( array1 );
17
18 printf( "Values in array2 by row are:\n" );
19 printArray( array2 );
20
21 printf( "Values in array3 by row are:\n" );
22 printArray( array3 );
23
24 return 0; /* indicates successful termination */
25
26 } /* end main */
27
28 /* function to output array with two rows and three columns */ 27
29 void printArray( const int a[][ 3 ] )
30 {
31 int i; /* row counter */
32 int j; /* column counter */
33
34 /* loop through rows */
35 for ( i = 0; i <= 1; i++ ) {
36
37 /* output column values */
38 for ( j = 0; j <= 2; j++ ) {
39 printf( "%d ", a[ i ][ j ] );
40 } /* end inner for */
41
42 printf( "\n" ); /* start new line of output */
43 } /* end outer for */
44
45 } /* end function printArray */

Values in array1 by row are:

1 2 3
4 5 6
Values in array2 by row are:
1 2 3
4 5 0
Values in array3 by row are:
1 2 0
4 0 0
1 /* Fig. 6.22: fig06_22.c 28
2 Double-subscripted array example */
3 #include <stdio.h>
4 #define STUDENTS 3
5 #define EXAMS 4
6
7 /* 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 );
12
13 /* function main begins program execution */
14 int main( void )
15 {
16 int student; /* student counter */
17
18 /* initialize student grades for three students (rows) */
19 const int studentGrades[ STUDENTS ][ EXAMS ] =
20 { { 77, 68, 86, 73 },
Each row in the array corresponds to a
21 { 96, 87, 89, 78 },
single student’s set of grades
22 { 70, 90, 86, 81 } };
23
24 /* output array studentGrades */
25 printf( "The array is:\n" );
26 printArray( studentGrades, STUDENTS, EXAMS );
27
28 /* determine smallest and largest grade values */ 29
29 printf( "\n\nLowest grade: %d\nHighest grade: %d\n",
30 minimum( studentGrades, STUDENTS, EXAMS ),
31 maximum( studentGrades, STUDENTS, EXAMS ) );
32
33 /* calculate average grade for each student */
34 for ( student = 0; student < STUDENTS; student++ ) {
35 printf( "The average grade for student %d is %.2f\n",
36 student, average( studentGrades[ student ], EXAMS ) );
37 } /* end for */
38
average function is passed a row of the array
39 return 0; /* indicates successful termination */
40
41 } /* end main */
42
43 /* Find the minimum grade */ 30
44 int minimum( const int grades[][ EXAMS ], int pupils, int tests )
45 {
46 int i; /* student counter */
47 int j; /* exam counter */
48 int lowGrade = 100; /* initialize to highest possible grade */
49
50 /* loop through rows of grades */
51 for ( i = 0; i < pupils; i++ ) {
52
53 /* loop through columns of grades */
54 for ( j = 0; j < tests; j++ ) {
55
56 if ( grades[ i ][ j ] < lowGrade ) {
57 lowGrade = grades[ i ][ j ];
58 } /* end if */
59
60 } /* end inner for */
61
62 } /* end outer for */
63
64 return lowGrade; /* return minimum grade */
65
66 } /* end function minimum */
67
68 /* Find the maximum grade */
69 int maximum( const int grades[][ EXAMS ], int pupils, int tests )
70 {
71 int i; /* student counter */
72 int j; /* exam counter */
73 int highGrade = 0; /* initialize to lowest possible grade */
74
75 /* loop through rows of grades */
76 for ( i = 0; i < pupils; i++ ) {
77
78 /* loop through columns of grades */
79 for ( j = 0; j < tests; j++ ) {
80
81 if ( grades[ i ][ j ] > highGrade ) {
82 highGrade = grades[ i ][ j ];
83 } /* end if */
84
85 } /* end inner for */
86
87 } /* end outer for */
88
89 return highGrade; /* return maximum grade */
90
91 } /* end function maximum */
92
93 /* Determine the average grade for a particular student */ 32
94 double average( const int setOfGrades[], int tests )
95 {
96 int i; /* exam counter */
97 int total = 0; /* sum of test grades */
98
99 /* total all grades for one student */
100 for ( i = 0; i < tests; i++ ) {
101 total += setOfGrades[ i ];
102 } /* end for */
103
104 return ( double ) total / tests; /* average */
105
106 } /* end function average */
107
108 /* Print the array */
109 void printArray( const int grades[][ EXAMS ], int pupils, int tests )
110 {
111 int i; /* student counter */
112 int j; /* exam counter */
113
114 /* output column heads */
115 printf( " [0] [1] [2] [3]" );
116
117 /* output grades in tabular format */ 33
118 for ( i = 0; i < pupils; i++ ) {
119
120 /* output label for row */
121 printf( "\nstudentGrades[%d] ", i );
122
123 /* output grades for one student */
124 for ( j = 0; j < tests; j++ ) {
125 printf( "%-5d", grades[ i ][ j ] );
126 } /* end inner for */
127
128 } /* end outer for */
129
130 } /* end function printArray */

The array is:

[0] [1] [2] [3]
studentGrades[0] 77 68 86 73
studentGrades[1] 96 87 89 78
studentGrades[2] 70 90 86 81

Lowest grade: 68
Highest grade: 96
The average grade for student 0 is 76.00
The average grade for student 1 is 87.50
The average grade for student 2 is 81.75
References

Paul Deitel and Harvey Deitel, C How to

Program, 7 Ed., Pearson Education, 2012.