1 Data Structures Searching Techniques Namiq Sultan.

1

Data Structures

Searching Techniques

Namiq Sultan

2

Searching Techniques

Searching is a process of checking and finding an element from a list of elements.

1. Linear or Sequential Searching

2. Binary Searching

3. Fibanocci Search

3

LINEAR OR SEQUENTIAL SEARCHING

In linear search, each element of an array is read one by one sequentially and it is compared with the desired element.

A search will be unsuccessful if all the elements are read and the desired element is not found.

4

ALGORITHM FOR LINEAR SEARCH

Let A be an array of n elements, A[0],A[1],A[2], ... A[n-1], “data” is the element to be searched. Then this algorithm will find the location “loc” of data in A. Set loc = – 1, if the search is unsuccessful.

Input an array a of n elements and “data” to be searched Initialize loc = – 1, and i = 0Repeat

If (data = a[i]) then loc = i

End if If (loc > -1) then

display “data is found and searching is successful”Else

display “data is not found and searching is unsuccessful”End ifi++

End repeat

5

PROGRAMMING SEQUENTIAL SEARCH

void main()

{

char opt;

int arr[20],n,i,item;

cout << “\nHow many elements in the array : ”;

cin >> n;

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

{

cout << “\nEnter element ” << i+1 << “: “;

cin >> arr[i];

}

cout << “\n\nPress any key to continue....”;

cin.get();

6

PROGRAMMING SEQUENTIAL SEARCHdo{

cout<< “\nEnter the element to be searched : ”;

cin >> item; //Input the item to be searched

for(i=0;i < n;i++){

if(item == arr[i]){

cout << (“Item found at position : ”, i+1);

break;

}

}/*End of for*/

if (i == n)

cout << “\nItem “ << item << “ not found ...\n”;

cout << “\n\nPress (Y/y) to continue : ”;

cin >> opt;

}while(opt == ‘Y’ || opt == ‘y’);

}

7

BINARY SEARCH

Binary search is an extremely efficient algorithm when it is compared to linear

search. Binary search technique searches “data” in minimum possible

comparisons. Suppose the given array is a sorted one, otherwise first we have to

sort the array elements.

8

ALGORITHM OF BINARY SEARCHInput an array A of n elements and “data” to be searched

LB = 0, UB = n-1, mid = int ((LB+UB)/2)

while (LB <= UB) and (A[mid] != data)

If (data < A[mid]) then

UB = mid–1

Else

LB = mid + 1

End if

mid = int ((LB + UB)/2)

End while

If (A[mid]== data) then

Display “the data found”

Else

Display “the data is not found”

End if

9

PROGRAM OF BINARY SEARCH

void main(){

char opt;const n=10;int arr[20], start, end, middle, i, item;for(i=0; i < n; i++){ cout << “\nEnter element: ” << i+1 << “ : “; cin >> arr[i];}cout <<(“\n\nPress any key to continue...”);cin.get();

do {

cout<<“\nEnter the element to be searched : ”;

cin>>item;

10

start=0;

end=n – 1;

middle=(start + end)/2;

while(item != arr[middle] && start < end) {

if (item > arr[middle]) start=middle+1;

else end=middle-1;

middle=(start+end)/2;

}

if (item==arr[middle])

cout<<“Item found at position ”<<middle+1<<endl;

else if(start>end) cout<<“Item not found in array\n”;

cout<<“\n\nPree (Y/y) to continue : ”;

cin >> opt;

}while(opt == ‘Y’ || opt == ‘y’);

}/*End of main()*/

PROGRAM OF BINARY SEARCH

11

• Hashing is a technique where we can compute the location of the desired record in order to retrieve it in a single access (or comparison).

• The information to be retrieved is stored in a hash table which is best thought of as an array of m locations, called buckets. The hash table have a key/value relationship.

• The keys are unique, that is, no two distinct values have the same key.

• Hash table has only a few methods, such as insert, erase, and find.

HASH TABLE

12

• Suppose “persons” is a hash table that will hold up to 1000 values. Each value consists of a unique 3-digit integer (the key), and a name.

HASH TABLE

key name0123

999

index

13

HASH TABLE

key value

108

Jalal351

Dilshad

453 Ali

0

1

108

351

453

999

WHERE SHOULD WE STORE THE FOLLOWING PERSONS?

Persons [351] = “Jalal”;persons [108] = “Dilshad”;Persons [435] = “Ali”;

14

HASH TABLE• Now for something slightly different: suppose “persons” is a hash table that

holds up to 1000 values. Each value consists of  a 11-digit telephone number (the key), and a name.

persons [07506543210] = “Jalal”;

persons [07503301256] = “Dilshad”;

persons [07503309816] = “Ali”;

persons [07503576256] = “Dina”; • WHERE SHOULD THESE VALUES BE STORED?

• To make these values fit into the table, we need to mod by the table size; i.e., key % 1000.

07506543210 210

07503301256 256

07503309816 816

07503576256 256 !!!!! Collision

15

HASH TABLEkey value

07506543210 Jalal

07503301256 Dilshad

07503309816 Ali

0

1

210

256

816

999

16

HASH TABLE• when two different keys map to the same index, that is called a

collision.

• hashing: an algorithm that transforms a key into an array index.

• The algorithm has two parts:

1. a hash function: an easily computable operation on the key that

returns an index in the array buckets;

Hash(Key) = Integer

2. a collision handler.

Hash Function

17

• Input: a field of a record; usually its key K (student id, name, … )

• Compute index function H(K)

H(K): K A

To find the address of the record.

H(K) is address of the record with key K

• Example 1:

• Key is student id (six digits), we have 100,000 records positions (0-

99,999)

• H(K): student_id mod 99999

085768 085768 mod 99999 = 85768

134281 134281 mod 99999 = 34282

101004 101004 mod 99999 = 1005

Hash Function

18

Example 2:

• Key is a name

• H(K): Take first two characters, multiply their ASCII decimal values, add

the last three digits and take its mod 9 as H(K)

K = Lokman 76 * 111 = 8436

H(K) = 4+3+6 = 13 mod 9 = 4 key value

0

1

2

3

4 Lokman

5

Collisions

• Usually, ideal hashing is not possible (or at least not guaranteed).

Some data is bound to hash to the same table element, in which

case, we have a collision.

• How do we solve this problem?

Hashing 20

Collision Handlers

• Chaining• Linear Probing (Open Addressing)• Double Hashing• Quadratic Hashing

21

Chaining

07506543210 Jalal

07503301256 Dilshad

07503309816 Ali

0

1

210

256

816

999

07503576256 Dina

• Chaining is simple, but requires additional memory outside the table

• For each element of the table, a linked list is maintained to hold data that map to the same location. This list can grow as items are entered into the list.

Linear Probing• The idea is that even though these number hash to the same

location, they need to be given a slot based on their hash number index. Using linear probing, the entries are placed into the next available position.

• Consider the data with keys: 24, 42, 34,62,73 into a table of size 10. These entries can be placed into the table at the following locations:

Linear Probing

• 24 mod10 = 4. Position is free. 24 placed into element 4

• 42 mod10 = 2. Position is free. 42 placed into element 2

• 34 mod10 = 4. Position is occupied. Try next place in the table (5).

34 placed into position 5.

• 62 mod10 = 2. Position is occupied. Try next place in the table (3).

62 placed into position 3.

• 73 mod10 = 3. Position is occupied. Try next place in the table (4).

Same problem. Try (5). Then (6).

73 is placed into position 6.

Advantages and Disadvantages of Hash Table+ Very fast insertion and searching.

+ Relatively easy to program as compared to trees.

- Based on arrays, hence difficult to expand.

- No convenient way to visit the items in a hash table in any kind of order.

24

Example//data structure to hold id and data, our data-structure we want to use

struct person{

int id; //to hold a unique id for each person

char name[20]; // name of a person

};

class hasher{

person dt[11]; //the table to hold hashed data structs

int numel; //number of elements in table, to check if it's full

public:

hasher();

int hash(int id);

int rehash(int id);

void add(person d);

void output();

};

Example/*this is the function to give hashed id, it's a simple one...

It's good to use a prime number for table length, thats why I used 11,

it's better because we reduce our collisions*/

int hasher::hash(int id)

{ return (id%11); }

/*in case of any collision we use rehash function instead of hash*/

int hasher::rehash(int id)

{ return ((id+1)%11); }

hasher::hasher() { //create an array of data structure

int i;

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

dt[i].id = -1; //set all ids to -1 to show they're empty

strcpy(dt[i].name,""); //set all name values to empty

}

numel = 0;

}

Examplevoid hasher::add(person p) { if(numel < 11) { //table has empty places...

int hashed = hash(p.id);if (dt[hashed].id == -1) { //slot is empty, assign new data

dt[hashed].id = p.id; strcpy(dt[hashed].name, p.name);

} else { //we need to rehash the id

while (1) { //try every place in table to find an empty placehashed = rehash(hashed);if (dt[hashed].id == -1) {

dt[hashed].id = p.id;strcpy(dt[hashed].name, p.name);break;

} }

} } else cout<<"Table is full\n\n";}

Examplevoid hasher::output() { int i; for(i=0; i<11; i++) { cout<< I <<" ->\t“ << dt[i].id << "\t“ << dt[i].name << endl; }}

int main() { person d[11]={ 123, "Ahmed Ali",

733, "Basim Taha", 380, "Careen Fady",

890, "Emad Salah",460, "Fatin Ahmed",156, "Ghali Shukri",222, "Hadi Ali",101, "Iman Edward",444, "Jamal Nassir",611, "Karim Morad",999, "Lolo Kareem“

};

Example

hasher h1; int i=0; for (i=0; i<11; i++) { h1.add(d[i]); //add this record to table } h1.output(); //see the output return 0;

}