Chapter 8: Arrays

```CHAPTER 4
ARRAY
Prepared by MMD, Edited by MSY
1
Arrays
Introduction to arrays
 Declaring arrays
 Initializing arrays
 Examples using arrays
 Relationship with pointers
 Array passing to a function
 Simple sorting: bubble sort
 Simple searching: linear sort
 2-dimensional array

Prepared by MMD, Edited by MSY
2
Introduction to Arrays

Built-in C data types:



Fundamental data types – char, int, double, float, void and
variations of int and double. When a variable is declared as
one of these types, the compiler reserves a memory location
for the variable and it can only store only one value at a time.
Derived data types – derived from fundamental data types eg.
pointers, arrays, structures and unions.
An array is a group of memory locations related by the
fact that they all have the same name and the same
type.
Prepared by MMD, Edited by MSY
3
Introduction to Arrays Cont…


To refer to a particular location or element in the
array, we specify the name of the array and the
position number of the particular element in the array.
The size of an array is static (fixed) throughout
program execution.
Prepared by MMD, Edited by MSY
4
Let say we have an array called A
Name of the array
The position number within
the square brackets is formally
called a subscript. A subscript
can be an integer or an integer
expression. For example if
x = 1 and y = 2, then A [x+y]
is A [3].
Position/index number of the
element within the array
Notice that the position
starts from 0.
A[0]
-10
A[1]
99
A[2]
-8
A[3]
100
A[4]
27
A[5]
1
A[6]
1976
A[7]
-2020
1
A[8]
Prepared by MMD, Edited by MSY
5
Declaring Arrays


Array declaration is made by specifying the data
type and the number of space so that the computer
may reserve the appropriate amount of memory.
General syntax:
data_type array_name[size]

Examples:




int my_array[100];
char name[20];
double bigval[5*200];
int a[27], b[10], c[76];
Prepared by MMD, Edited by MSY
6
Initializing Arrays

1.
There are 2 ways to initialize an array:
during compilation and during execution.
During compilation:

Unsized array e.g int arr[] = {1, 2, 3, 4, 5};


Sized array e.g int arr[3] = {90, 21, 22};

2.
We can define how many elements that we want since
the array size is not given.
We can define only 3 elements since the array size is
During execution:
int arr[3], j;
for (j = 0; j < 3; j++)
arr[j] = 0;
Prepared by MMD, Edited by MSY
7
Examples Using Arrays
#include <stdio.h>
#define SIZE 5
Output:
void main(void) {
int temp[SIZE], i;
for (i = 0; i < SIZE; i++)
temp[i] = i*9;
printf(“%s %13s\n”, “Element”, “Value”);
for (i = 0; i < SIZE; i++)
printf(“%7d%13d\n”, i, temp[i]);
}

Element
0
1
2
3
4
Value
0
9
18
27
36
In the example above, an array with the name temp and size 5 has
been declared. The elements in the array has been given the value
position*9. The first for loop is equivalent to this:
temp[0] = 0*9
temp[1] = 1*9
temp[2] = 2*9
temp[3] = 3*9
temp[4] = 4*9
Prepared by MMD, Edited by MSY
8
Example:
#include <stdio.h>
#define SIZE 10
void main(void) {
int list[SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int i, total = 0;
for (i=0; i < SIZE; i++) {
total += list[i];
}
printf(“Total of array element values is %d.\n”, total);
}
Output:
Total of array element values is 45.
Prepared by MMD, Edited by MSY
9
Example:
#include <stdio.h>
#define SIZE 20
void main(void) {
int list[SIZE];
int n, i, total = 0;
float avg;
//user enter how many values to key in and validate it
printf(“enter the size of the data: ”);
scanf(“%d”, &n);
if(n<20){
for (i=0; i < n; i++) {
//read values and store in array Output:
Total of array element values
printf(“enter value %d :”, i);
scanf(“%d”, &list[i]);
total += list[i];
}
//find average
avg=total/n;
printf(“Total of array element values is %d.\n”, total);
printf(“Average= %.2f\n”, avg);
}
else
printf(“the size of the data is exceeding the array size”);
Prepared by MMD, Edited by MSY
}
is 45.
10
Relationship with Pointers
The name of an array is actually a pointer to
the first element in the array.
 Therefore, if we have:

int test[3] = {9, 10, 11};
printf(“%d”, *test);
The output would be: 9

There are a few ways to traverse an array:
int test[3] = {9, 10, 11}, k;
for (k = 0; k < 3; k++)
printf(“%d\n”, test[k]);
int test[3] = {9, 10, 11}, k;
int *ptr = test;
for (k = 0; k < 3; k++, ptr++)
Prepared by MMD, Edited by MSY
printf(“%d\n”, *ptr);
11
Array Passing to a Function

A function that is going to receive an array as one of
the arguments can be declared in 2 ways:
void Process(char name[]) OR
void Process(char *name)


When we pass an array to a function, we are
actually passing the pointer to the first element in
the array to the function. Therefore, any changes to
the array inside the function will also change the
actual array.
Either the array is passed using [] or using *, the
array can be accessed in the same way.
Prepared by MMD, Edited by MSY
12
Passing Array to a Function Cont…

Assume that we have the following array
declaration.
int marks[10] = {0};


Say for example we want to write a function,
called get_marks, which will read marks from the
user and store the marks inside the array.
When we want to pass an array to a function, we
need to know these 3 things.



How to write the function prototype?
How to do function call?
How does the function header would look like?
Prepared by MMD, Edited by MSY
13
Passing Array to a Function Cont…

Function prototype:
/* data type with square bracket */
void get_marks(int [ ]);
void get_marks(int *); /*treating array as pointer */

Function call:
get_marks(marks); /* just pass the array name */

void get_marks(int marks[ ])
void get_marks(int *marks) /*treating array as
pointers */
Prepared by MMD, Edited by MSY
14
Example 1: parameter received as an array
#include <stdio.h>
#define size 10
void get_marks(int [ ]);
int calc_average(int [ ]);
void main(void)
{
int marks[size] = {0}; /*initializing the array */
get_marks(marks); /* function call */
printf(“Average for marks given is %d”,
calc_average(marks));
}
Prepared by MMD, Edited by MSY
15
Example 1: parameter received as an array
void get_marks(int marks[ ])
{
int i;
for (i = 0; i < size; i++)
{
printf("Marks student %d:",i + 1);
scanf("%d",&marks[i]);
}
int calc_average(int marks[ ])
}
{
int total = 0, i;
for (i = 0; i < size; i++)
{
total = total + marks[i];
}
}
Prepared by MMD, Edited by MSY
16
Example 2: parameter received as pointers

A function could also receive/treat array parameter as
pointer.
#include <stdio.h>
#define size 10
void get_marks(int *);
int calculate_average(int *);
Observe the
function prototypes
void main(void)
{
int marks[size] = {0};
get_marks(marks);
printf("Average for marks given is %d\n",
calculate_average(marks));
}
Prepared by MMD, Edited by MSY
17
Example 2: parameter received as pointers
void get_marks(int *marks)
{
int i;
for (i = 0; i < size; i++, marks++)
{
printf("Marks student %d: ", i + 1);
scanf("%d", marks);
}
}
int calculate_average(int *marks)
{
int i, total = 0;
for (i = 0; i < size; i++, marks++)
{
total = total + *marks;
}
return (total / size);
}
Prepared by MMD, Edited by MSY
Pointer variable
18
Example 3:
#include <stdio.h>
#define SIZE 10
int CountAvg(int *);
void main(void) {
}
int i, temp;
for (i=0 ; i<SIZE; i++) {
scanf(“%d”, &temp)
}
}
int i, total=0;
for (i=0; i<SIZE; i++)
return (total/SIZE);
}
Prepared by MMD, Edited by MSY
19
The Read() and CountAvg() functions can also
be written this way:
int i;
for (i = 0; i < SIZE; i++, ptr++) {
scanf(“%d”, &(*ptr))
}
}
int i, total;
for (i = 0, total = 0; i < SIZE; i++, ptr++)
total += *ptr;
return (total/SIZE);
}
Prepared by MMD, Edited by MSY
20
Sorting



Sorting is the process of placing data into a
particular order such as ascending or descending.
There are many sorting algorithms that are usually
used. Among them are bubble sort, selection sort,
insertion sort and shell sort.
Here, we will discuss how bubble sort can be used
to sort the elements in an array.
Prepared by MMD, Edited by MSY
21
Bubble Sort




In bubble sort, the list is divided into two sublists:
sorted and unsorted.
The smallest element is bubbled from unsorted
sublist and moved to the sorted sublist.
Each time an element moves from the unsorted
sublist to the sorted sublist, one sort is completed.
The bubble concept is shown in figure below :
1
j
Sorted
k
n
Unsorted
Prepared by MMD, Edited by MSY
22
Bubble Sort cont…

Figure below shows how the wall moves one
element in each pass.
23 78 45
8
32 56
Original list
Unsorted


it to 32. Since 56 > 32, it is not moved and we step
down one element.
No changes take place until we compare 45 to 8.
Since 8 < 45, the two elements are exchanged
(swapped).
Prepared by MMD, Edited by MSY
23
Bubble Sort cont…
The two elements are swapped and we step
down 1 element.
 Because 8 was moved down, it is now compared
to 78 and these two elements are swapped.
 Finally, 8 is compared to 23 and exchanged.
This series of exchanges places 8 in the first
location and the wall is moved up one position.

8
23 78 45 32 56
After pass 1
Unsorted
Prepared by MMD, Edited by MSY
24
Bubble Sort cont…
8 23
32 78 45 56
After pass 2
Unsorted
8 23 32
Sorted
8 23 32 45
45 78 56
After pass 3
Unsorted
56 78
After pass 4
Sorted!
Sorted
Prepared by MMD, Edited by MSY
25
Let us look at the C code:
void main(void) {
int list[] = {23, 78, 45, 8, 32, 56};
BubbleSort(list);
}
void BubbleSort (int list[]) {
int i, j, temp, swapped = 1;
for (i = 0; i < 6 && swapped == 1; i++) {
swapped = 0;
for (j = 0; j < (6-i); j++) {
if (list[j] > list[j+1]) { // Swap
temp = list[j];
list[j] = list[j+1];
list[j+1] = temp;
swapped = 1;
}
}
}
}
Prepared by MMD, Edited by MSY
26
Simple Searching




Searching is the process of determining whether an
array contains a value that matches a certain key
value.
Same as in sort, there are more than one algorithms
that can be used to do a search.
Here, we will discuss how can we do a linear search
on an array.
Linear search is a simple searching algorithm where:


data are stored in an array
a key value is compared with each elements in the array
starting from the first element
Prepared by MMD, Edited by MSY
27
Let us look at the C code:
Sample Output:
Enter the number that you want to find: 53
The number 53 is found at location 1
Press any key to continue
void main(void) {
int list[] = {34, 53, 21, 23, 4};
int i, key_value, found = 0;
printf(“Enter the number that you want to find: ”);
scanf(“%d”, &key_value);
for (i = 0; i < 5; i++) {
if (list[i] == key_value) {
found = 1;
printf(“The number %d is found at location %d\n”, key_value, i);
break;
}
}
if (found == 0)
printf(“The number %d cannot be found in the list\n”, key_value);
}
Prepared by MMD, Edited by MSY
28
2-Dimensional Array


It is possible to create an array which has more than
one dimension.
For example:



2D array: int array[4][2];
3D array: int array[4][2][10];
Graphical representation of a 2D array:
int myarray[4][2] = {1, 2, 3, 4, 5, 6, 7, 8};
1
2
3
4
5
6
8
7
This array has 4 rows and 2
columns.
Prepared by MMD, Edited by MSY
29
2-Dimensional Array Cont…

Variable initialization can also be done this way:
int myarray[4][2] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
int test_score[4][3]={{95,80,78},{69, 75,81}, {100,98,100},
{98,85,87}};

This method is less confusing since we can see the rows
and columns division more clearly.
To initialize a 2D array during execution, we need to use
a double loop (nested loop):
for (i = 0; i < 4; i++)
for (j = 0; j < 2; j++)
total=total + myarray[i][j];

Although it is possible to create a multi-dimensional
array, arrays above 2-dimensions are rarely used.
Prepared by MMD, Edited by MSY
30
Passing 2D Array to Function


When a 2D (or higher dimensional) array is passed to
a function, the size of the second (or subsequent)
subscript needs to be specified.
For example, if we have:
int twoD[4][5];
Then a function which would take twoD as an
argument should be declared like this:
void Process2D(int td[][5])

An array is stored consecutively in memory
regardless of the number of dimensions. Therefore,
specifying the subscripts in the function parameter
will help the compiler to know the boundary of the
different dimensions.
Prepared by MMD, Edited by MSY
31
Example
Sample program 1
Sample program 2
Prepared by MMD, Edited by MSY
32
SUMMARY

In this chapter, we have looked at:






Array declaration and initialization
Reading and writing from/to array elements
Passing array to function
Array sorting : BubbleSort
Simple searching : Linear Search
2 dimensional array
Prepared by MMD, Edited by MSY
33
```