Algorithms & Computing

Lecture #9
Instructor: Jahan Zeb
Department of Computer Engineering (DCE)
College of E&ME
NUST
 Searching Arrays: Linear Search

 Search array for a key value

 Linear search
– Compare each element of array with key value
• Start at one end, go to other
– Useful for small and unsorted arrays
• Inefficient
• If search key not present, examines every element
1
2 // Linear search of an array.
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 int linearSearch( const int [], int, int ); // prototype
10
11 int main()
12 {
13 const int arraySize = 100; // size of array a
14 int a[ arraySize ]; // create array a
15 int searchKey; // value to locate in a
16
17 for ( int i = 0; i < arraySize; i++ ) // create some data
18 a[ i ] = 2 * i;
19
20 cout << "Enter integer search key: ";
21 cin >> searchKey;
22
23 // attempt to locate searchKey in array a
24 int element = linearSearch( a, searchKey, arraySize );
25
26 // display results
27 if ( element != -1 )
28 cout << "Found value in location " << element << endl;
29 else
30 cout << "Value not found" << endl;
31
32 return 0; // indicates successful termination
33
34 } // end main
35
36 // compare key to every element of array until location is
37 // found or until end of array is reached; return subscript of
38 // element if key or -1 if key not found
39 int linearSearch( const int array[], int key, int sizeOfArray )
40 {
41 for ( int j = 0; j < sizeOfArray; j++ )
42
43 if ( array[ j ] == key ) // if found,
44 return j; // return location of key
45
46 return -1; // key not found
47
48 } // end function linearSearch
Enter integer search key: 36
Found value in location 18

Enter integer search key: 37

Value not found
 Multiple-Subscripted Arrays

 Multiple subscripts
– a[ i ][ j ]
– Tables with rows and columns
– Specify row, then column
– “Array of arrays”
• a[0] is an array of 4 elements
• a[0][0] is the first element of that array
Column 0 Column 1 Column 2 Column 3
Row 0 a[ 0 ][ 0 ] a[ 0 ][ 1 ] a[ 0 ][ 2 ] a[ 0 ][ 3 ]

Row 1 a[ 1 ][ 0 ] a[ 1 ][ 1 ] a[ 1 ][ 2 ] a[ 1 ][ 3 ]

Row 2 a[ 2 ][ 0 ] a[ 2 ][ 1 ] a[ 2 ][ 2 ] a[ 2 ][ 3 ]

Column subscript

Array name
Row subscript
 Multiple-Subscripted Arrays

 To initialize
– Default of 0
– Initializers grouped by row in braces
1 2
int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } }; 3 4
Row 0 Row 1

1 0

int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } }; 3 4
 Multiple-Subscripted Arrays

 Referenced like normal

cout << b[ 0 ][ 1 ]; 1 0

– Outputs 0 3 4

– Cannot reference using commas

cout << b[ 0, 1 ];
• Syntax error
 Function prototypes
– Must specify sizes of subscripts
• First subscript not necessary, as with single-scripted arrays
– void printArray( int [][ 3 ] );
1 // Fig. 4.22: fig04_22.cpp
2 // Initializing multidimensional arrays.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 void printArray( int [][ 3 ] );
9
10 int main()
11 {
12 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };
13 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 };
14 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } };
15
16 cout << "Values in array1 by row are:" << endl;
17 printArray( array1 );
18
19 cout << "Values in array2 by row are:" << endl;
20 printArray( array2 );
21
22 cout << "Values in array3 by row are:" << endl;
23 printArray( array3 );
24
25 return 0; // indicates successful termination
26
27 } // end main
28
29 // function to output array with two rows and three columns
30 void printArray( int a[][ 3 ] )
31 {
32 for ( int i = 0; i < 2; i++ ) { // for each row
33
34 for ( int j = 0; j < 3; j++ ) // output column values
35 cout << a[ i ][ j ] << ' ';
36
37 cout << endl; // start new line of output
38
39 } // end outer for structure
40
41 } // 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
 Pointers

 Pointers
– Powerful, a bit tricky
– Simulate pass-by-reference
– Close relationship with arrays and strings
 Pointer Variable Declarations and
Initialization
 Pointer variables
– Contain memory addresses as values count

7
– Normally, variable contains specific value (direct reference)
  – Pointers contain address of variable that has specific value
(indirect reference) countPtr count
7
 Indirection
– Referencing value through pointer
 Pointer declarations
– * indicates variable is pointer
int *myPtr;
declares pointer to int, pointer of type int *
– Multiple pointers require multiple asterisks
int *myPtr1, *myPtr2;
 Pointer Variable Declarations and
Initialization
 Can declare pointers to any data type
 Pointer initialization
– Initialized to 0, NULL, or address
• 0 or NULL points to nothing
 Pointer Operators

 & (address operator)

– Returns memory address of its operand
– Example
int y = 5;
int *yPtr;
yPtr = &y; // yPtr gets address of y
– yPtr “points to” y

y yptr y
5 500000 600000 600000 5
yPtr

address of y
is value of
yptr
 Pointer Operators

 * (indirection/dereferencing operator)
– Returns synonym for object its pointer operand points to
– *yPtr returns y (because yPtr points to y).

*yptr = 9; // assigns 9 to y
 * and & are inverses of each other
1
2 // Using the & and * operators.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 int main()
9 {
10 int a; // a is an integer
11 int *aPtr; // aPtr is a pointer to an integer
12
13 a = 7;
14 aPtr = &a; // aPtr assigned address of a
15
16 cout << "The address of a is " << &a
17 << "\nThe value of aPtr is " << aPtr;
18
19 cout << "\n\nThe value of a is " << a
20 << "\nThe value of *aPtr is " << *aPtr;
21
22 cout << "\n\nShowing that * and & are inverses of "
23 << "each other.\n&*aPtr = " << &*aPtr
24 << "\n*&aPtr = " << *&aPtr << endl;
25
26 return 0; // indicates successful termination
27
28 } // end main

The address of a is 0012FED4

The value of aPtr is 0012FED4
 
The value of a is 7
The value of *aPtr is 7
 
Showing that * and & are inverses of each other.
&*aPtr = 0012FED4
*&aPtr = 0012FED4