P Surendra Varma et al, International Journal of Research in computer
and communication Technology , Vol 6, Issue- 3,March- 2017
SPRY Search - A Novel Algorithm
1*
P Surendra Varma, 2P.P.N.G Phani Kumar, 3B.H.V.S Narayana, 4D.V.S Ravi Varma
1,2,3,4
Asst. Professor
1,2,3,4
Dept. Of CSE, Raghu Engg. College
ABSTRACT
Since the inception of algorithms, various
searching procedures have already been developed to
sort a given list of values. Most of these algorithms
perform the searching procedure based on the index of
the integer array in which these values are stored.
When the value at a particular index of the array does
not match with the key value, we move on to one more
index and compare the value at that particular index.
For any searching procedure we keep on selecting new
indices until we find the key element, but the only
difference is in the method of selecting the new index.
The time complexity of an algorithm depends
on the procedure by which we select the new index.
Efficient selection of the index value reduces the
complexity of an algorithm. Spry Search (Spry, a
synonym of quick) focuses on efficient procedure to
select the new index value, thereby results in finding
the key value at a faster rate.
Key words- index, key based, array.
I. INTRODUCTION
There are already many existing procedures
to perform searching. One of them searches the list
sequentially. i.e., it selects the first element of the list,
checks whether it is the required key value. If yes, the
problem is solved and the procedure terminates,
otherwise select the next element of the list, repeat the
same process until the required key value is found.
On the other hand, there are various searching
algorithms which require the data to be sorted before
the actual searching procedure begins. Then the idea is
to compare the middle element of the list with the key.
If the key is found, the procedure terminates,
otherwise we check if the key is lesser or greater than
the middle element. If it is greater, we search half of
the list which is greater than this list, else if it is lesser,
we search the other half.
In this way whenever the key value is not
found, the further processing is done only on half of
the present list. So the list gets reduced to half every
time the key is not found. Here the basic idea is, the
searching time reduces recursively just because the list
is halved every time.
www.ijrcct.org | *Corresponding Author 66
ISSN (Online) 2278- 5841
ISSN (Print) 2320- 5156
II. PROPOSED PROCEDURE
Spry Search Algorithm assumes the data to be
sorted before beginning the actual search procedure
and works best when the data is uniform(list of values
with equal difference between them). But how does it
select the next data value to be compared with the
key?
This selection is based on the equations given below:
acd = (element at index low + element at index
high) / (low +high)
New Index = key / acd
Where low and high are the starting and ending
indices of the array respectively.
Variable acd represents Approximate Common
Difference.
What are we actually trying to do by applying
these two equations? We are trying to find the
approximate position of key value based on first and
last element of the array.
How does it Work? Consider the train
coaches at a railway platform. You have a ticket
reserved in Coach S6. You are at present 100 meters
behind Coach S1 and 900 meters behind Coach S9. So
how many meters do you need to walk to reach your
Coach S6? 600 meters, Isnt it?.
How did we get 600? We get 600 from the two
calculations shown below:
(100 + 900) / (1+9) = 100
100 * 6 = 600.
We implemented the same procedure in the form of
two equations shown above.
You are exactly 600 meters behind your required
coach S6 provided:
All the coach numbers are sorted
The length of all the coaches is same.
Typically, you would not assume one coach to be 100
meters and the other to be 50 meters.
Applying the same two conditions:
We already said that this searching algorithm
operates only on sorted data. So the first
assumption is done.
 P Surendra Varma et al, International Journal of Research in computer
and communication Technology , Vol 6, Issue- 3,March- 2017
Difference between the data need not be
uniform in all the cases. When the length of
all the coaches is not the same, after walking
for 600 meters you would reach coach s6 or
some other coach which is definitely nearer to
the required S6. So you need not walk more
to reach S6, it would be somewhere nearby.
The same concept applies to the list of data
values. When the data is not uniform, we
might reach a value which is nearer to the key
value. So we again start searching from there.
As we are already nearer to the key value.
This might not take much time to reach the
key value.
III. ALGORITHM
1. Consider indices of the array start from 1. At
the start of algorithm, low = 1 and high is
the number of elements in the given list,
key is the value to be searched.
2. Find the new index based on the below two
equations:
a. acd = (element at index low +
element at index high) / (low
+high)
b. new_index = key / acd
3. Check whether a[new_index] is equal to the
key value.
a. If it is equal, we found the key
value. So terminate the algorithm
successfully.
b. Else if a[new_index] is less than key
value, then repeat the procedure
from Step 2 with low =
new_index+1.
c. Else repeat the procedure from Step
2 with high = new_index-1
IV. IMPLEMENTATION
int search(int a[],int low, int high, int key)
{ 6
int index,acd;
acd = (a[low]+a[high])/(low+high);
index = key/acd;
iteration++;
printf("\n Pass number: %d, searching at location:
%d",iteration,index);
if(low>high)
return 0;
else
{
if(a[index]==key)
return index;
else if(a[index]<key)
search(a,index+1,high,key);
else
search(a,low,index-1,key);
}
www.ijrcct.org | *Corresponding Author 67
ISSN (Online) 2278- 5841
ISSN (Print) 2320- 5156
}
In the program, we have used the statement
iteration++ to find out how many passes this
algorithm takes to search for key value. The value of
variable iteration is incremented for every pass
starting with 1.
V. ANALYSIS:
While analyzing spry search, every time we
try to find the new index value, we move nearer to the
required key value, but by how much nearer? It takes
us nearer to the key such that half of the unwanted
array values are discarded every time.
To understand this, let us consider we have
32 values in the array. For the 1st pass of the algorithm
the array values are reduced to half if the key element
is not found. So now we are left with only 16 values.
Similarly for 2nd pass the array values are reduced by
half again, so only 8 are left. And the process
continues until we find the required key value.
There is a mathematical function present
which can be represented for halving a particular value
every time. The function is a logarithmic function. A
logarithmic function with base 2. Base 2 logarithmic
values of some values are given below:
0 log 21
1 log 22
2 log 24
3 log 28
4 log 216
5 log 232
log 264
7 log 2128
8 log 2256
9 log 2512
10 log 21024
20 log 21048576
21 log 22097152
Here are the graphs showing logn vs n:
 P Surendra Varma et al, International Journal of Research in computer
and communication Technology , Vol 6, Issue- 3,March- 2017
So the time complexity of this algorithm can be said to
be O(logn).
Best Case:
This algorithm works best when the list of
elements are uniform i.e. if they have equal difference
between each pair of values.
Screenshot for best case scenario:
www.ijrcct.org | *Corresponding Author 68
ISSN (Online) 2278- 5841
ISSN (Print) 2320- 5156
In the above shown output, the data entered
10, 20, 30, 40, 50, 60 has uniform difference
between each pair of values which is 10. So we could
find the key value only within one pass.
Average Case:
This algorithm doesnt work too good nor
too bad when the data has approximately uniform
difference between each pair of values.
Screenshot for average case scenario:
In the above output, look at the difference between
each pair of a values. The differences are 9, 9, 7, 14, 6,
15 which are not equal differences and at the same
time, they are not too unequal differences.
In such a case, we were able to find the key
value within 2 passes.
Worst case:
This algorithm works worst when the
difference between each pair of values is not common
at all i.e, the differences of each pair vary by a large
number.
Screenshot for worst case scenario:
 P Surendra Varma et al, International Journal of Research in computer ISSN (Online) 2278- 5841
and communication Technology , Vol 6, Issue- 3,March- 2017
ISSN (Print) 2320- 5156

11.http://www.tutorialspoint.com/data_structures_algo
rithms/interpolation_search_algorithm.htm

12.http://www.tutorialspoint.com/data_structures_algo
rithms/hash_data_structure.htm

13.https://en.wikipedia.org/wiki/Analysis_of_algorith
ms

14. http://discrete.gr/complexity/

15.http://www.cprogramming.com/tutorial/computersc
iencetheory/algorithmicefficiency2. html

16.https://www.cs.utexas.edu/users/djimenez/utsa/cs17
23/lecture2.html

17.https://www.cpp.edu/~ftang/courses/CS240/lecture
s/analysis.htm

In the above output, there is a lot of variation

between the differences which are 28, 9, 4, 30, 24.
They do not appear to be common at all.
In such a case, the algorithm took 3 passes to
locate the key value.

VI. REFERENCES:

1. Data Structure with C, Seymour Lipschutz, TMH

2. Data Structures using C,Reema Thareja, Oxford

3. Data Structures, 2/e, Richard F, Gilberg , Forouzan,

Cengage

4. Data structures and algorithm analysis in C, 2nd ed,

mark allen weiss

5. Data Structures and Algorithms, 2008,G.A.V.Pai,

TMH

6. Classic Data Structures, 2/e, Debasis

,Samanta,PHI,2009

7. Fundamentals of Data Structure in C, 2/e,

Horowitz,Sahni,Anderson Freed,University Press.

8.http://www.tutorialspoint.com/data_structures_algori
thms/algorithms_basics.htm

9.http://www.tutorialspoint.com/data_structures_algori
thms/linear_search_algorithm.htm

10.http://www.tutorialspoint.com/data_structures_algo
rithms/binary_search_algorithm.htm

www.ijrcct.org | *Corresponding Author 69