Scribd
Upload
36 views15 pages

Week 3: Linear (Sequential) Search 2. Binary Search 3. Complexity of Algorithms

This document discusses searching techniques and algorithm complexity. It covers linear and binary search algorithms. Linear search sequentially compares elements to find a match, with average time complexity of O(n). Binary search compares the middle element and recursively searches half the list, with average time complexity of O(log2n) for sorted lists. Algorithm complexity is measured using Big O notation, which describes how time or space required grows relative to input size. Common classifications include constant, linear, quadratic, logarithmic, and super-polynomial time.

Uploaded by

Mhd Bazzi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
36 views15 pages

Week 3: Linear (Sequential) Search 2. Binary Search 3. Complexity of Algorithms

This document discusses searching techniques and algorithm complexity. It covers linear and binary search algorithms. Linear search sequentially compares elements to find a match, with average time complexity of O(n). Binary search compares the middle element and recursively searches half the list, with average time complexity of O(log2n) for sorted lists. Algorithm complexity is measured using Big O notation, which describes how time or space required grows relative to input size. Common classifications include constant, linear, quadratic, logarithmic, and super-polynomial time.

Uploaded by

Mhd Bazzi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Week 3

CHAPTER 3: SEARCHING TECHNIQUES


1. LINEAR (SEQUENTIAL) SEARCH
2. BINARY SEARCH
3. COMPLEXITY OF ALGORITHMS
SEARCHING TECHNIQUES

 To finding out whether a particular element is


present in the list.
 2 methods: linear search, binary search
 The method we use depends on how the
elements of the list are organized
– unordered list:
 linear search: simple, slow
– an ordered list
 binary search or linear search: complex, faster
1. LINEAR (SEQUENTIAL) SEARCH

 How?
– Proceeds by sequentially comparing the key with
elements in the list
– Continues until either we find a match or the end
of the list is encountered.
– If we find a match, the search terminates
successfully by returning the index of the element
– If the end of the list is encountered without a
match, the search terminates unsuccessfully.
1. LINEAR (SEQUENTIAL) SEARCH

void lsearch(int list[],int n,int element)


{ int i, flag = 0;
for(i=0;i<n;i++)
if( list[i] == element)
{ cout<<“found at position”<<i);
flag =1;
break; } flag: what for???
if( flag == 0)
cout<<“ not found”;
}
1. LINEAR (SEQUENTIAL) SEARCH

int lsearch(int list[],int n,int element)


{ int i, find= -1;
for(i=0;i<n;i++)
if( list[i] == element) Another way using flag

{find =i;
break;}
return find;
} average time: O(n)
2. BINARY SEARCH

 List must be a sorted one


 We compare the element with the element
placed approximately in the middle of the list
 If a match is found, the search terminates
successfully.
 Otherwise, we continue the search for the
key in a similar manner either in the upper
half or the lower half.
Baba? Eat?
void bsearch(int list[],int n,int element)
{
int l,u,m, flag = 0;
l = 0; u = n-1;
while(l <= u)
{ m = (l+u)/2;
if( list[m] == element)
{cout<<"found:"<<m;
flag =1;
break;}
else
if(list[m] < element)
l = m+1;
else
u = m-1;
} average time: O(log2n)
if( flag == 0)
cout<<"not found";
}
BINARY SEARCH: Recursion
int Search (int list[], int key, int left, int right)
{
if (left <= right) {
int middle = (left + right)/2;
if (key == list[middle])
return middle;
else if (key < list[middle])
return Search(list,key,left,middle-1);
else return Search(list,key,middle+1,right);
}
return -1;
}
3. COMPLEXITY OF ALGORITHMS

 In Computer Science, it is important to measure the


quality of algorithms, especially the specific amount
of a certain resource an algorithm needs
 Resources: time or memory storage (PDA?)
 Different algorithms do same task with a different set
of instructions in less or more time, space or effort
than other.
 The analysis has a strong mathematical background.
 The most common way of qualifying an algorithm is
the Asymptotic Notation, also called Big O.
3. COMPLEXITY OF ALGORITHMS
 It is generally written as

 Polynomial time algorithms,


– O(1) --- Constant time --- the time does not change in response to
the size of the problem.
– O(n) --- Linear time --- the time grows linearly with the size (n) of
the problem.
– O(n2) --- Quadratic time --- the time grows quadratically with the
size (n) of the problem. In big O notation, all polynomials with the
same degree are equivalent, so O(3n2 + 3n + 7) = O(n2)
 Sub-linear time algorithms
– O(logn) -- Logarithmic time
 Super-polynomial time algorithms
– O(n!)
– O(2n)
3. COMPLEXITY OF ALGORITHMS

 Example1: complexity of an algorithm


void f ( int a[], int n )
{
int i; 2 * O(1)? + O(N)
cout<< "N = “<< n;
for ( i = 0; i < n; i++ )
cout<<a[i];
printf ( "n" );
} O(N)
?
3. COMPLEXITY OF ALGORITHMS

 Example2: complexity of an algorithm


void f ( int a[], int n )
{ int i;
cout<< "N = “<< n; 2)
2 * O(1) + O(N)+O(N
?
for ( i = 0; i < n; i++ )
for (int j=0;j<n;j++)
cout<<a[i]<<a[j];

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


cout<<a[i]; O(N2)
?
printf ( "n" );
}
3. COMPLEXITY OF ALGORITHMS

 Linear Search
– O(n).
 Binary Search
– O(log2 N)

You might also like