Data Structure

Department of Computer Science and Software

Engineering
Capital University of Sciences & Technology,
Islamabad Pakistan

1
 Arrays in Data Structure
 An array is a collection of more then one data items
or elements of same datatype in contiguous
memory (one after another) e.g. list of names, list of scores
 Easier way to compare and use data than having
separate variables for data elements
 data_type identifier[size]
 int arr[3]
 declares a one-dimensional array named arr with space

for 3 integer variables

 Variables contiguous in memory; lowest address
has first value, next address has second variable
value, and so on
 Arrays
• An array is an indexed data structure
• An array stores a collection of variables
• All variables stored in an array are of the same
data type
• An individual variable within an array is called an
element of the array
• An element of an array is accessed using the array
name and an index
• The name of the array is the address of the first
element. The index is the offset
 Declaring an array
data_type array_name[size];
– allocates memory for size variables
– index of first element is 0
– index of last element is size-1
– size must be a constant
 Arrays
 An individual variable within an array is called an
element of the array
 The elements of an array are not named, and
are accessed by the array’s name and their
position in the array (indexing)
 Index of first element is zero, index of last
element is size-1 e.g. int arr[3] has variables
arr[0], arr[1] and arr[2]
 size has to be a positive constant (not variable)
i.e. can’t do: int x = 3; int arr[x];
but can do: int arr[3 * 2];
 Number of bytes reserved with int arr[3]; ?
 Declaring an Array
• Example: int list[10];
– allocates memory for 10 integer variables
– index of first element is 0
– index of last element is 9
– C++ does not perform any bounds checking on arrays
list[0]
list[1]

list[9]
 Arrays
Arrays offer convenient means of grouping
together several related variables
One- dimensional arrays

type var_name[size]
int sample[10];
double d[30];
char ch[100];
Arrays in Data Structure

 Array is can be initialized by two ways;

 One when it is declared (Static initialization)
 int arr[3] = {15, 25, 3};
 Equal or Less not more elements
 Run time initialization
 Using loop or functions
 Initializing Arrays
Arrays can be initialized at the time they are
declared.

Examples:
double taxrate[3] = {0.15, 0.25, 0.3};
char word[] = “hello”;
char list[5] = {‘h’,’e’,’l’,’l’,’o’};
//list of characters, not a string
double vector[100] = {0.0}; //assigns zero to all 100 elements
 Initializing Arrays
 float f[5]={0.0, 1.0, 2.0, 3.0, 4.0};
// initializes f[0] to 0.0, f[1] to 1.0…f[4] to 4.0
 Or
 float f[5]; f[0]=0.0; f[1]=1.0; …

 int a[10]={2}; //rest initialized to zero

cout << a[0]<< endl << a[5] << endl;

 If no size given, allocates as much as the no. of initializers

e.g. int a[] = {5, 2, -9}; // and
int a[3] = {5, 2, -9}; // are equivalent

 Can’t do: int hand[2]; hand[2]={5, 9};

 Can’t do: short y[2]={1,2,3,4};

 Don’t confuse: short b[4] and b[4]

 Initializing Arrays
 for loops used to initialize arrays

#include <iostream.h>

int main()
{
int t, sample[10]; // this reserves 10 integer
elements

// load the array

for(t=0; t<10; ++t)
sample[t]=t;

// display the array

for(t=0; t<10; ++t)
cout << sample[t] << ' ';

return 0;
}
 Initializing Arrays
int a[5];
 Now an indexed variable like a[1] can be used anywhere that a variable of
type int can be used

int a[5];
cin >> a[4] >> a[2];
cout << a[2] << “ “ << a[4] << endl;

cin >> a[3] >> a[0];

int max; max = a[3] + a[0]; cout << max << endl;

int next; cin >> next;

a[1]= next; cout << a[1] << endl;
a[3]= 42; cout << a[3] << endl;

int student = 2;
a[student] = 99;
cout << a[student] << “ “ << a[2] << endl;

 Also: a[get_index())] = 3; if get_index() returns an int

//Reads in 5 scores, displays max_score and shows
//how much each score differs from max_score

int main()
{
const int SIZE = 5;
int i, score[SIZE], max_score;

cout << “Enter “ << SIZE << “ scores: \n”;

cin >> score[0];
max_score = score[0];

for (i=1; i<SIZE; i++)

{
cin >> score[i];
if (score[i] > max_score)
max_score=score[i];
}

cout << “The highest score is: “ << max_score << endl
<< “Scores & their difference from highest: \n”;

for (i=0; i<SIZE; i++)

{
cout << score[i] << “ off by “
<< (max_score – score[i]) << endl;
}
return 0;
}
 Initializing Arrays
 Useful to give a constant name to the size of array

/*const type modifier*/

const int NUM_EMPLOYEES = 10;
int salaries[NUM_EMPLOYEES];

for (int i=0; i < NUM_EMPLOYEES; i++)

cin >> salaries[i];

 Advantage? Why not use a variable name?

 Another way:
# define NUM_EMPLOYEES 10
 And yes, sizeof(salaries); gives what?
 Arrays
• Total size of an array in bytes?

• Total bytes =
number of bytes in type * number of elements

• e.g. int sample[10];

• Has size in bytes = 10 * sizeof(int)
 Initializing Arrays
• What is wrong with the following?
int num=10;
int iarray[num];

int size;
cin >> size;
int myarray[size];

double darray[5]={3.2, 4.5, 6.7, 324.0, 45.8, 23.1, 34.9}

 Assigning One Array to Another
int a[10], b[10];

// ...

a = b; // error -- illegal
/*So how do we make the contents of one array
same as the other?*/
 Assigning One Array to

Another
int a[5], b[5];
// ...
a = b; // error – illegal

 Cannot assign one array to another; each element must

be copied individually
const int ARRAY_SIZE = 5;
int a[] = {10, 11, 12, 13, 14};

int main()
{
int b[ARRAY_SIZE];

for (int i=0; i < ARRAY_SIZE; ++i)

b[i] = a[i];

return 0;
}
 Assigning Values to an Array
•Example

int list[10];
int count;

cin >> count;

for(int i=0; i<count; i++)

cin >> list[i];

What if count >9?

 Summarize Arrays
• In C++ all arrays are stored in contiguous memory
locations

• An individual element is accessed by use of an index.

• An index describes the position of an element within

an array.

• In C++ all arrays have zero as the index of their first

element.
 Arrays: Min Max
int main()
{
const int SIZE = 10;
int i, min_value, max_value;
int list[SIZE];

for(i=0; i<SIZE; i++)

{
list[i] = rand();
cout<<list[i]<<" ";
}
 Arrays
// find minimum value
min_value = list[0];

for(i=0; i<SIZE; i++)

{
if (min_value>list[i])
{
min_value = list[i];
}
}
cout << "minimum value: " << min_value << ‘\n’;
 Arrays
// find maximum value
max_value = list[0];

for(i=0; i<SIZE; i++)

{
if (max_value<list[i])
{
max_value = list[i];
}
}
cout << "maximum value: " << max_value << '\n';
return 0;
} // end of main function
 Arrays - No Bounds Checking
// An incorrect program. Do Not Execute!
int main()
{
int crash[10], i;

for(i=0; i<100; i++)

crash[i]=i;

return 1;
}
 Two Dimensional Arrays
• C++ supports multi-dimensional array
– data_type array_name[ROW_SIZE][COLUMN_SIZE]
– int matrix[3][4];

row[0]
row[1]
row[2]
in memory
row1 row2 row3
 Accessing Array Elements
• int matrix[3][4];
– matrix has 12 integer elements
– matrix[0][0] element in first row, first column
– matrix[2][3] element in last row, last column
 Two Dimensional Arrays
int main()
{
const int ROWS = 3;
const int COLS = 4;
int i, j, num[ROWS][COLS];

for(i=0; i<ROWS; ++i)

{
for(j=0; j<COLS; ++j)
{
num[i][j] = (i*COLS)+j+1;
cout << num[i][j] << “\t“;
}
cout << “\n”;
}
return 0;
} // output?
Output:
1 2 3 4
5 6 7 8
9 10 11 12
 Two Dimensional Arrays
What happens if I change [3][4] to [2][6]?
int main()
{
const int ROWS = 3;
const int COLS = 4;
int i, j, num[ROWS][COLS];

for(i=0; i<ROWS; ++i)

{
for(j=0; j<COLS; ++j)
{
num[i][j] = (i*COLS)+j+1;
cout << num[i][j] << “ “;
}
cout << “\n”;
}
return 0;
} // output?
Output:
1 2 3 4 5 6
7 8 9 10 11 12
Multidimentional Arrays
 type name[size1][size2] . . . [sizeN];

 int multidim[4][10][3];

 when multidimensional arrays are used,

large amounts of memory are consumed.
Multidimensional Array Initialization
int sqrs[10][2] = {
1, 1,
2, 4,
3, 9,
4, 16,
5, 25,
6, 36,
7, 49,
8, 64,
9, 81,
10, 100
};
Multidimensional Arrays
int main(void)
{
const int ALPHABETS = 26;
char code[ALPHABETS][2] =
{
{'a', 'f'}, {'b', 'w'}, {'c', 'x'},
{'d', 'v'}, {'e', 's'}, {'f', 'r'},
{'g', 'q'}, {'h', 'c'}, {'i', 'g'},
{'j', 'h'}, {'k', 'e'}, {'l', 'u'},
{'m', 'b'}, {'n', 'j'}, {'o', 'd'},
{'p', 'k'}, {'q', 't'}, {'r', 'l'},
{'s', 'm'}, {'t', 'n'}, {'u', 'a'},
{'v', 'o'}, {'w', 'p'}, {'x', 'z'},
{'y', 'i'}, {'z', 'y'}
};
Multidimensional Arrays
int i;
char alpha;

cout << "Enter an alphabet: ";

cin >> alpha;

for(i=0; i< ALPHABETS; i++)

{
if(code[i][0]==alpha)
{
cout << "The code of " << alpha
<< " is ";
cout << code[i][1]<<endl;
break;
}
}
return 0;
} // end of main program
C++ automatic array

int entry [31]; value has to be

known at compile time

entry

34 45 15 ---------- 36
0 1 2 ----------- 30

entry[0] = = *entry NO HEAP MEMORY

SPACE IN USE!
C++ dynamic arrays
 can use dynamic memory allocation to postpone
decision about array capacity until run-time
 array space will be on the heap
 pointer to array's beginning is not on the heap

float * dynArray; // declare pointer only

dynArray = new float [max]; // max is a variable
// use of dynamic array the same as use of an automatic array
delete [ ] dynArray; // free heap space
 Dynamic Allocation
const int SIZE = 10;
double *ptr = new double[SIZE]; /*10 element array*/
int i;

for (i=0; i<SIZE; i++)

{
ptr[i] = 2.0*i;
}

for (i=0; i<SIZE; i++)

{
cout << ptr[i] << endl;
}

delete []ptr;
 Array of Pointers
const int RSIZE = 4;
A two dimensional
const int CSIZE = 6; array of
int * iarray[RSIZE]; RSIZE*CSIZE

for(int k=0; k<RSIZE; k++) 012345

iarray
{ 0
iarray[k] = new int [CSIZE]; 1
if (iarray[k] == NULL) 2
{ 3
cerr << “Memory Allocation Error…\n”;
cerr << “Exiting …\n”;
exit(-1);
}
}
 Double and Tripple Pointers
int a = 20;
int *ip = &a; 300 200 100 20
int **ipp = &ip; ippp ipp ip a
int ***ippp = &ipp; 400 300 200 100

cout << a << endl; 20

cout << ip << *ip << endl; 100 20
cout << ipp << *ipp << **ipp << endl; 200 100 20
cout << ippp << *ippp << **ippp << ***ippp << endl;
300 200 100 20
 Dynamic Array of Pointers
const int RSIZE = 4;
A two dimensional
const int CSIZE = 6; array of RSIZE*CSIZE
int ** matrix;

matrix = new int * [RSIZE]; matrix 012345

for(int k=0; k<RSIZE; k++) 0
{ 1
matrix[k] = new int [CSIZE]; 2
if (matrix[k] == NULL) 3
{
cerr << “Memory Allocation Error…\n”;
cerr << “Exiting …\n”;
exit(-1);
}
}