Module4 Searching Techniques

Programming and Data Structures
Debasis Samanta
Computer Science & Engineering
Indian Institute of Technology Kharagpur
Spring-2017
Lecture #11
Searching Techniques
CS 11001 : Programming and Data Structures 2 Lecture #11: © DSamanta

Today’s discussion…
* Searching Techniques
* Sequential search with arrays

• Binary search
• Interpolation search
* Sequential search with linked lists

Searching Techniques

S e a rc h in g
In te re n a l s e a rc h in g E x te rn a l s e a rc h in g
B tre e s e a rc h in g
B + tre e s e a rc h in g
S e a rc h w ith k e y -c o m p a ris o n S e a rc h w ith o u t k e y -c o m p a ris o n
A d re s s c a lc u la tio n s e a rc h
L in e a r s e a rc h N o n -lin e ra s e a rc h
S e q u e n tia l s e a rc h T re e se a rc h
B in a ry s e a rc h B in a ry s e a rc h tre e
In te rp o la tio n s e a rc h A V L tre e s e a rc h
R e d -b la c k tre e s e a rc h
S p la y tre e s e a rc h
D ig ita l s e a rc h
M u lti-w a y tre e s e a rc h
m -w a y tre e s e a rc h
B -tre e s e a rc h
G ra p h se a rc h
D e p th firs t s e a rc h
B re a d th firs t s e a rc h

Linear Search

Sequential Search with Arrays

Flowchart: Sequential Search with Array
Start
i=0
Yes No
K = A[i]?
i = i+1
No
Print "Successful" i≥n
Yes
Print "Unsuccessful"
Stop

Example: Sequential Search with Array
int
int main()
main()
{{
int
int A[10],
A[10], i,
i, n,
n, K,
K, flag
flag == 0;
0;
printf("Enter
printf("Enter the
the size
size of
of an
an array:
array: ");
");
scanf("%d",&n);
scanf("%d",&n);
printf("Enter
printf("Enter thethe elements
elements ofof the
the array:
array: ");
");
for(i=0;
for(i=0; ii << n;
n; i++)
i++)
scanf("%d",&A[i]);
scanf("%d",&A[i]);
printf("Enter
printf("Enter thethe number
number toto be
be searched:
searched: ");
");
scanf("%d",&K);
scanf("%d",&K);
for(i=0;i<n;i++){
for(i=0;i<n;i++){
if(a[i]
if(a[i] ==== K){
K){
flag
flag == 1;
1; break;
break;
}}
}}
if(flag
if(flag ==
== 0)
0)
printf("The
printf("The number
number is
is not
not in
in the
the list");
list");
else
else
printf("The
printf("The number
number is
is found
found at
at index
index %d",i);
%d",i);
return
return 0;
0;
}}

Complexity Analysis
• Case 1: The key matches with the first element

• T(n) = 1
• Case 2: Key does not exist
• T(n) = n
• Case 3: The key is present at any location in the array
n
T ( n)  p
i 1
i i
1
1 n
T (n)   i p1  p 2     pi     p n 
n i 1 n
n 1
T ( n) 
2
Complexity Analysis : Summary
Number of key Asymptotic

Case Remark
comparisons complexity
Case 1 T(n) = 1 T(n) = O(1) Best case
Case 2 T(n) = n T(n) = O(n) Worst case
Case 3 n 1 T(n) = O(n) Average case

T ( n) 
2

Binary Search

The Technique
m imd i d
l l u m= i md i=d -l (1l=+ um ) i/ d2 + 1 S e ra c h th is h a lf th e s a m e w a y
uu
S e ra c h th is h a lf th e s a m e w a y
if K < A [m id ] if K > A [ m id ]
( c ) S( ae( )ba r)Ac Shn e toah rr ecd he rnt eht dier eae rnl ri tasi tyr et ou l fri snet sl te iumnr tnno se ttihsn etwo s iett hha er ic nshedi ane rxgc hvo iafn l gur ei ogs fh l t,l- ehu fatal- fnh dao lnfml oyi dn l y

Flowchart: Binary Search with Array
Start
mid = (l+u)/2
YES NO
K = A[mid]?
YES NO
K < A[mid]?
Search is successful
u = mid-1 l = mid+1
Stop
NO
(l>u)?
YES
Search is unsuccessful
Start
Binary Search (with Iteration)
#include
#include <stdio.h>
<stdio.h>
int
int main()
main()
{{
int
int i,
i, l,
l, u,
u, mid,
mid, n,
n, K,
K, data[100];
data[100];
printf("Enter
printf("Enter number
number of
of elements\n");
elements\n");
scanf("%d",&n);
scanf("%d",&n);
printf("Enter
printf("Enter %d
%d integers
integers in
in sorted
sorted order\n",
order\n", n);
n);
for
for (i
(i == 0;
0; ii << n;
n; i++)
i++)
scanf("%d",&array[i]);
scanf("%d",&array[i]);
printf("Enter
printf("Enter value
value to
to find\n");
find\n");
scanf("%d", &K);
scanf("%d", &K);
ll == 0;
0;
uu == nn -- 1;
1; Contd…
mid
mid == (l+u)/2;
(l+u)/2;

Binary Search (with Iteration)
while
while (l
(l <=
<= u)
u) {{
if
if (data[mid]
(data[mid] << K)
K)
ll == mid
mid ++ 1;
1;
else
else if (data[mid] ==
if (data[mid] == K)
K) {{
printf("%d
printf("%d found
found at
at location
location %d.\n",
%d.\n", search,
search, mid+1);
mid+1);
break;
break;
}}
else
else
uu == mid
mid -- 1;
1;
mid
mid == (l
(l ++ u)/2;
u)/2;
}}
if
if (l
(l >> u)
u)
printf("Not
printf("Not found!
found! %d
%d is
is not
not present
present in
in the
the list.\n",
list.\n", K);
K);
return
return 0;
0;
}}

Binary Search (with Recursion)
#include<stdio.h>
#include<stdio.h>
int
int main(){
main(){
int
int data[100],i,
data[100],i, n,
n, K,
K, flag,
flag, l,
l, u;
u;
printf("Enter
printf("Enter the
the size
size of
of an
an array:
array: ");
");
scanf("%d",&n);
scanf("%d",&n);
printf("Enter
printf("Enter the
the elements
elements of
of the
the array
array in
in sorted
sorted order:
order: "" );
);
for(i=0;i<n;i++)
for(i=0;i<n;i++)
scanf("%d",&a[i]);
scanf("%d",&a[i]);
printf("Enter
printf("Enter the
the number
number to
to be
be search:
search: ");
");
scanf("%d",&K);
scanf("%d",&K);
l=0,u=n-1;
l=0,u=n-1;
flag
flag == binarySearch(data,n,K,l,u);
binarySearch(data,n,K,l,u);
if(flag==0)
if(flag==0)
printf("Number
printf("Number is
is not
not found.");
found.");
else
else
printf("Number
printf("Number is
is found.");
found.");
Contd…
return
return 0;
0;
}}
Binary Search (with Recursion)
int
int binary(int
binary(int a[],int
a[],int n,int
n,int K,int
K,int l,int
l,int u){
u){
int
int mid;
mid;
if(l<=u){
if(l<=u){
mid=(l+u)/2;
mid=(l+u)/2;
if(K==a[mid]){
if(K==a[mid]){
return(1);
return(1);
}}
else
else if(m<a[mid]){
if(m<a[mid]){
return
return binarySearch(a,n,K,l,mid-1);
binarySearch(a,n,K,l,mid-1);
}}
else
else
return
return binarySearch(a,n,m,mid+1,u);
binarySearch(a,n,m,mid+1,u);
}}
else
else return(0);
return(0);
}}

Complexity Analysis
5
< = >
2 8
< = > < = >
1 3 6 9
< = > < = > < = > < = >
F F F 4 F 7 F 10
< = > < = > < = >
F F F F F F

Complexity Analysis: Binary Search
5
< = >
2 8
< = > < = >
1 3 6 9
< = > < = > < = > < = >
F F F 4 F 7 F 10
< = > < = > < = >
F F F F F F
Let n be the total number of elements in the list under search and there exist an integer k such that:-
• For successful search:-
• If 2 k 1  n  2 k, then the binary search algorithm requires at least one comparison and at most k comparisons.
• For unsuccessful search:-
• If , then the binary search algorithm requires k comparisons.
n  2 k 1
• If 2 k 1  n  2 k  1 , then the binary search algorithm requires either k-1 or k number of comparisons.

• Best case
T(n) = 1
• Worst case
T(n) =  log 2  n  1 

• Average Case
• Successful search:-
I
T ( n)  1
n
T ( n)   log 2 n    log 2 n   2  1
n n
• Unsuccessful search:-
E
T ' ( n) 
n 1
2
T ' (n)   log 2 n  
n 1

Interpolation Search

1. l = 1, u = n // Initialization: Range of searching
2. flag = FALSE // Hold the status of searching
3. While (flag = FALSE) do
 K  A[l ] 
4. loc  
A[u ]  A [l ]   u  l  l
 
5. If ( l  loc  u ) then // If loc is within the range of the list
6. Case: K < A[loc]
7. u = loc -1
8. Case: K = A[loc]
9. flag = TRUE
10. Case: K > A[loc]
11. l = loc +1
12. Else
13. Exit()
14. EndIf
15. EndWhile
16. If (flag) then
17. Print “Successful at” loc
18. Else
19. Print “Unsuccessful”
20. EndIf
21. Stop

Complexity Analysis:
Best case Worst case Average case
Successful 1 n log 2  log 2 n 
Interpolation search
Unsuccessful n
n n

Comparision: Successful Search
100
80 S e a rc h a rra y
Time (  s)
60
B in a r y s e a r c h
40
I n t e r p o la t io n s e a r c h
20
0 S e a r c h lis t
10 100 500 1000 5000 10000
In p u t S iz e

Comparision: Unsuccessful Search
100
80 S e a rc h A rra y
Time (  s)
60
B in a r y S e a r c h
40
In t e r p o la t io n s e a r c h
20
0 S e a r c h lis t
10 100 500 1000 5000 10000
In p u t S iz e

Sequential Search with Linked List

Sequential Search with Linked List
D A TA L IN K
(a ) S tru c tu re o f a n o d e in th e lin k e d lis t
H eader
S e a rc h a t a n in te rm e d ia te n o d e :
S e a rc h b e g in s S e a rc h s to p s h e re if k e y m a tc h e s S e a rc h u n s u c c e s s fu lly e n d s h e re
h e re e ls e m o v e to its im m e d ia te n e x t n o d e
(b ) L in e a r s e a rc h o n a lin k e d lis t

Flow Chart: Sequential Search with LL
Start
temp = header
while
Print Unsuccessful
temp != NULL
temp = temp->next
T
N temp->data == Y
key
Print Success
Return temp

Example: Sequential Search with LL
#include
#include <stdio.h>
<stdio.h>
#include
#include <stdlib.h>
<stdlib.h>
struct
struct node
node
{{
int
int data;
data;
struct
struct node
node *next;
*next;
};
};
int
int main()
main()
{{
struct
struct node
node *header
*header == NULL;
NULL;
int
int K,
K, n;
n;
printf("Enter
printf("Enter the
the number
number of
of nodes:
nodes: ");
");
scanf("%d",
scanf("%d", &n);
&n);
printf("\nDisplaying
printf("\nDisplaying the
the list\n");
list\n");
generate(header, num);
generate(header, num);
printf("\nEnter
printf("\nEnter key
key to
to search:
search: ");
");
scanf("%d", &key);
scanf("%d", &key);
searchBinary(header,
searchBinary(header, K);
K);
delete(header);
delete(header);
return
return 0;
0;
}}

Example: Linear Search with LL
void
void generate(struct
generate(struct node
node *head,
*head, int
int n)
n)
{{
int
int i;
i;
struct
struct node
node *temp;
*temp;
for
for (i
(i == 0;
0; ii << num;
num; i++)
i++)
{{
temp
temp == (struct
(struct node
node *)malloc(sizeof(struct
*)malloc(sizeof(struct node));
node));
temp->data = rand()
temp->data = rand() % n; % n;
if
if (*header
(*header == == NULL)
NULL)
{{
*header
*header == temp;
temp;
temp->next
temp->next == NULL;
NULL;
}}
else
else
{{
temp->next
temp->next == header;
header;
header = temp;
header = temp;
}}
printf("%d
printf("%d ", ", temp->data);
temp->data);
}}
}}

Example: Linear Search with LL
void
void searchBinary(struct
searchBinary(struct node
node *temp,
*temp, int
int K)
K)
{{
while
while (temp
(temp !=
!= NULL)
NULL)
{{
if
if (temp->data
(temp->data ==
== K)
K)
{{
printf("key
printf("key found\n");
found\n");
return;
return;
}}
else
else temp
temp == temp->next;
temp->next;
}}
printf("Key
printf("Key not
not found\n");
found\n");
}}
void
void delete(struct
delete(struct node
node *header)
*header)
{{
struct
struct node
node *temp;
*temp;
temp = header;
temp = header;
while
while (temp
(temp !=
!= NULL)
NULL)
{{
temp
temp == temp->next;
temp->next;
free(header);
free(header);
header
header == temp;
temp;
}}
}}

Complexity Analysis
Number of key
Case Asymptotic complexity Remark
comparisons
Case 1 T(n) = 1 T(n) = O(1) Best case
n 1
Case 2 T ( n)  T(n) = O(n) Average case
2
Case 3 T(n) = n T(n) = O(n) Worst case

Any question?
You may post your question(s) at the “Discussion

Forum” maintained in the course Web page.
Problems to ponder…
1. What will be the time complexity of linear search with array if the array is already in sorted order?
2. What will be the outcome, if Binary search technique is applied to an array where the data are not
necessarily in sorted order?
3. Whether the Binary search technique is applicable to a linked list? If so, how?
4. In Binary Search, the mid location is calculated and then either left or right part of the mid location is
searched further, if there is no match at the middle is found. As an alternative to check at middle, the
location at one-third (or two-third) position of the array is chosen. Such a searching can be termed as
Ternary Search. Modify the Binary Search algorithm to Ternary Search algorithm. Which algorithm gives
result faster?
5. If T(n) denotes the number of comparisons required to search a key element in a list of n elements, then a)
express T(n) as recursion formula and b) solve T(n).

Problems to ponder…
6. Out of sequential search and binary search, which is faster? Why?
7. Whether binary search technique can be applied to search a string in a list od strings stored in an array? If
so, revise the Binary search algorithm accordingly.
8. A structure is defined as follows.

struct Record {
int RollNo;
char name[20];
struct Date { int dd; int mm; int yy; } dob;
}
suppose, 100 records of type Record are stored in an array say, struct Record students[100];
We have to find the student(s), whose date of birth is given in the form dd/mm/yy. How you can search the
array students?

If you try to solve problems yourself, then you will learn
many things automatically.
Spend few minutes and then enjoy the study.

Module4 Searching Techniques

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Module4 Searching Techniques

Uploaded by

Copyright:

Available Formats

Programming and Data Structures

CS 11001 : Programming and Data Structures 2 Lecture #11: © DSamanta

* Sequential search with arrays

* Sequential search with linked lists

CS 11001 : Programming and Data Structures 3 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 4 Lecture #11: © DSamanta

S e a rc h w ith k e y -c o m p a ris o n S e a rc h w ith o u t k e y -c o m p a ris o n

CS 11001 : Programming and Data Structures 5 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 6 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 7 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 8 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 9 Lecture #11: © DSamanta

• Case 1: The key matches with the first element

Number of key Asymptotic

Case 1 T(n) = 1 T(n) = O(1) Best case

Case 2 T(n) = n T(n) = O(n) Worst case

Case 3 n 1 T(n) = O(n) Average case

CS 11001 : Programming and Data Structures 11 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 12 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 13 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 15 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 16 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 18 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 19 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 20 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 21 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 22 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 23 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 24 Lecture #11: © DSamanta

Best case Worst case Average case

Successful 1 n log 2  log 2 n 

CS 11001 : Programming and Data Structures 25 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 26 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 27 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 28 Lecture #11: © DSamanta

(a ) S tru c tu re o f a n o d e in th e lin k e d lis t

CS 11001 : Programming and Data Structures 29 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 30 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 31 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 32 Lecture #11: © DSamanta

CS 11001 : Programming and Data Structures 33 Lecture #11: © DSamanta

Case 1 T(n) = 1 T(n) = O(1) Best case

Case 3 T(n) = n T(n) = O(n) Worst case

CS 11001 : Programming and Data Structures 34 Lecture #11: © DSamanta

You may post your question(s) at the “Discussion

CS 11001 : Programming and Data Structures 36 Lecture #11: © DSamanta

8. A structure is defined as follows.

CS 11001 : Programming and Data Structures 37 Lecture #11: © DSamanta

Spend few minutes and then enjoy the study.

CS 10001 : Programming and Data Structures 38 Lecture #07: © DSamanta

You might also like