Built-in Arrays

C++ native array type

Two versions

fixed size arrays

array size is fixed and must be specified with a constant
expression at the declaration

we will see this type now

array pointers

array size is dynamically allocated

we will not see it in this course

use of both types are the same except definition

Built-in Array declaration

As we said, we will discuss fixed size built-in arrays, not the pointer

version with dynamic allocation

size must be able to be determined at compile time

constant, literal or an expression that involves constants and literals only

const int CLASSSIZE = 100;

// constant

string
double
int

// array of 100 strings

// array of 500 doubles
// array of 200 integers

names[CLASSIZE];
grades[CLASSIZE*5];
list[200];

The following array declaration is INVALID

int size;
cout "Enter how many students ? ";
cin >> size;
string names[size]; // array size cannot be a variable

Built-in array initialization at declaration

You may specify a list of initial values at declaration. See

following example:
string dayNames [] = {"Sunday", "Monday", "Tuesday",
"Wednesday", "Thursday","Friday", "Saturday"};

dayNames is an array with 7 elements of type string

0th element is Sunday, 1st is Monday, ...

not necessary to specify size (7), since the number of elements make

the size clear

but you can specify the size, if you wish

string dayNames [7] = {"Sunday", "Monday", "Tuesday",
"Wednesday", "Thursday","Friday", "Saturday"};

Assignment rules in arrays

tvectors with the same element type can be assigned to

each other by =

LHS vector becomes the same as the RHS vector

size and capacity also become the same

Built-in arrays cannot be assigned to each other by =

int coins[] ={1,5,10,25};
int temp[4];
temp = coins;
temp[1] = coins[2];

// illegal
// legal array element assignment

How can we assign coins to temp?

element by element
for (i=0; i<4; i++)
temp[i] = coins[i];

Passing built-in arrays as parameters

A built-in array can be passed only as reference

parameter or const-reference parameter

cannot be passed as value parameter

But, we do not use ampersand character, &, at

parameter declaration

and we do not specify the array size in array parameter

however array size is generally passed as another

integer parameter since we do not have a size()

member function for built-in arrays

reference parameter

void Change(int list[], int numElts);

void Print(const int list[], int numElts);
const-reference parameter

Built-in array demo

See fixlist.cpp (slightly modified from the version in

book)

Why did we use const in Print?

to avoid accidental changes in array list

Why did we pass numElts as parameter for the

number of elements in the array?

because we dont know the total number of elements in the

array while writing the functions

Example Fibonacci numbers

Used in many areas of Mathematics and Computer Science

F0 = 1
F1 = 1
Fn = Fn-1 + Fn-2
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

You can see many examples of Fibonacci numbers in nature

E.g. Increase of number of branches of trees in time

See http://www.mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/fibnat.html
for more examples
const int MAX_SIZE = 100;
int list[MAX_SIZE];
int k;
list[0] = list[1] = 1;
for (k=2; k < MAX_SIZE, k++)
{
list[k] = list[k-1]+list[k-2];
}

Arrays of structs

We can define vectors of structs

id

gpa

1250

name
lastname

struct student
{
unsigned int id;
string name, lastname;
double gpa;
};

id
1251

gpa
3.2

name
lastname

student class[11];
// a vector with 11 students
id

class[1].gpa = 3.2;

1260

name

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

class[i].id = i + 1250;

10
lastname

gpa

Vector of struct

Example

define a struct for a track on a CD

track number and title are fields

define a vector for 10 tracks

shuffle these 10 tracks at random

see shuffle.cpp (in book, but this version is slightly

modified)

Array Processing Examples 1

write a function that takes an array of integers as parameter and

returns the maximum of numbers in it

process all array elements for loop from 0 to arrays size - 1

int max (int v[], int boyut)
//pre: aray v is not empty
//post: return max of elements in v
{
int i, max_so_far = INT_MIN;
for (i=0; i < boyut; i++)
{
if (v[i] > max_so_far)
{
max_so_far = v[i];
}
}
return max_so_far;
}

Array Processing Examples 2 (vectorproc.cpp)

Write a function that takes an array of integers as parameter and returns true
if the array is sorted in ascending manner, false otherwise

may not process all array elements

In this type of rule-checking applications, a possible method is to assume that

the rule is satisfied before the loop and find a counterexample in the loop

bool issorted (int[] v)

//post: returns true if the array is acsending sorted
{
bool s = true; // initially assume that array is sorted
//in the function try to break this assumption
int i =1;
while (i < v.size() && s == true)
{ //check until the end of array or until a counterexample is found
if (v[i-1] > v[i])
// if not sorted
s = false;
// counterexample is found
i++;
}
return s;
}

Searching a vector

We can search for one occurrence, return true/false or the index

of occurrence
Search the vector starting from the beginning

Stop searching when match is found

We can search and count the number of occurrences and return

count
Search entire vector

Similar to one occurrence search, but do not stop after first
occurrence

We can search for many occurrences, but return occurrences in

another vector rather than count

In all these cases, we search the vector sequentially starting

from the beginning

This type of search is called sequential search

Counting search
int countmatches(const string[] a, int boyut,
const string & s)
// post: returns # occurrences of s in a
{
int count = 0;
int k;
for(k=0; k < boyut; k++)
{
if (a[k] == s)
{
count++;
}
}
return count;
}

How can we change this code to return the index of the

first occurrence?

One occurrence search

int firstmatch(const string[] a, int boyut,
const string& s)
// post: returns the index of occurrence of s in a, -1
// otherwise
{
int k;
for(k=0; k < boyut; k++)
{
if (a[k] == s)
{
return k;
}
}
return -1;
}

Does not search the entire array if one match is found

good for efficiency purposes

How could you modify this to return true/false?

Collecting search

Collect the occurrences in another vector
void collect(const string[] a, int boyut,
string[] matches)
// pre: matches is empty
// post: matches contains all elements of a with
//
first letter 'A'
{
int k;
for(k=0; k < boyut; k++)
{
if (a[k].substr(0,1) == "A")
{
matches[k] = a[k];
}
}
}

Binary search

Alternative to sequential search for sorted vectors

If a vector is sorted we can use the sorted property to

eliminate half of the vector elements with one

comparison

What number (between 1 and 100) do we guess first in

number guessing game?

Idea of creating program to do binary search

Check the middle element
If it has the searched value, then youre done!

If not, eliminate half of the elements of the vector

search the rest using the same idea

continue until match is found or there is no match

how could you understand that there is no match?

lets develop the algorithm on an example

we need two index values, low and high, for the search space

Binary Search (search for 62)

0

10

11

12 13

14

10 24 34 52 55 62 67 75 80 81 90 92 100 101 111

low=0
low = 0

mid=7
mid=3

low=4

high=6

high=6
mid=5

=>

FOUND

high=14

Binary Search (search for 60)

0

10

11

12 13

14

10 24 34 52 55 62 67 75 80 81 90 92 100 101 111

low = 0
low=0

mid=7
mid=3

high =14

high=6

low=4
high=6
mid=5
low=4 high=4
mid=4
low=5 high=4

=> NO MATCH FOUND STOP

Binary search code

int bsearch(string[] list, int boyut, const string& key)
// pre: boyut == # elements in list
// post: returns index of key in list, -1 if key not found
{
int low = 0;
// leftmost possible entry
int high = boyut-1;
// rightmost possible entry
int mid;
// middle of current range
while (low <= high)
{
mid = (low + high)/2;
if (list[mid] == key)
{
return mid;
}
else if (list[mid] < key)
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
return -1;
}

// found key, exit search

// key in upper half
// key in lower half

// not in list

Comparing Sequential and Binary Search

Table 8.1 Comparing sequential / linear search with binary search
Number of Items Examined (at worst)
List Size
Binary Search
Sequential Search
1
1
1
10
4
10
1,000
11
1,000
5,000
14
5,000
100,000
18
100,000
1,000,000
21
1,000,000
A Computer Science Tapestry page 375
Given a list of N elements:
Binary search makes on the order of log N operation
O(log N)
Linear (sequential) search takes on the order of N operations
O(N)

Sorting

One of the fundamental operations in Computer

Science

Given a randomly ordered array, sort it

ascending

descending

Many algorithms exists

some in Chapter 11

we will discuss two of them Selection Sort (11.1.1)

and Insertion Sort (11.1.2)

Analysis in 11.4

Selection Sort

N is the number of elements in vector/array

Find smallest element, move into 0th vector/array location

examine all N elements

0 .. N-1

Find next smallest element, move into first location

0th location is already the minimum

examine N-1 elements

1 .. N-1

Find next smallest element, move into 2nd location

0th and 1st locations are already the minimum two elements

examine N-2 elements

2 .. N-1

Generalize
for kth element, 0 <= k <= N-2
- find the minimum between kth and last element (element
with index N-1) of array
- swap the kth element with the minimum one

Selection Sort: The Code

void SelectSort(int[] a, int boyut)
// pre: a contains a.size() elements
// post: elements of a are sorted in
{
int j, k, temp, minIndex;
for(k=0; k < boyut - 1; k++)
{
minIndex = k;
//
for(j=k+1; j < boyut; j++)
{
if (a[j] < a[minIndex])
{
minIndex = j;
//
}
}
temp = a[k];
// swap
a[k] = a[minIndex];
a[minIndex] = temp;
}
}

non-decreasing order

minimal element index

new min, store index

min and k-th elements

Insertion Sort

Insert 1st element before or after 0th

first 2 sorted

Insert 2nd element (element with index 2) in

proper location

first 3 sorted

Generalize

insert kth element (element with index k) within first

k elements

first k+1 sorted

run this for all k between 1 .. N-1

Insertion Sort The Code

void InsertSort(string[] a, int boyut)
// precondition: a contains boyut elements
// postcondition: elements of a are sorted in nondecreasing order
{
int k, loc;
for(k=1; k < boyut; k++)
{
string hold = a[k];
// insert this element
loc = k;
// location for insertion
// shift elements to make room for hold (i.e. a[k])
while (0 < loc && hold < a[loc-1])
{
a[loc] = a[loc-1];
loc--;
}
a[loc] = hold;
}
}