A New Algorithm for Tiered Binary Search

Transcription

1 Int'l Conf. Foundations of Computer Science FCS'17 25 A New Algorithm for Tiered Binary Search Ahmed Tarek Engineering, Physical and Computer Sciences, Montgomery College, Rockville, Maryland, USA Abstract Due to strong application flavor, binary search and its derivatives are researched widely in computing literature. The new concept pertaining to multiple key search strategy was introduced by the author back in Since then, diverse research investigations are performed with a wide variety of multi-key search algorithms. In this paper, a new algorithm for tiered binary search is proposed. The algorithm performs multiple element binary search through tiered key search strategy that optimizes the search space even further compared to other previous versions. Foundational to tiered search is an extension of the basic binary search due to Newton s root search strategy. This enhanced algorithm computes the n-th root of a non-negative real number. The underlying concept pertaining to tiered binary search in finding multiple key elements with a single iteration in an organized search pool is presented, and the related algorithm is formally described. The algorithm is analyzed for clarity. Finally, application and future research avenues are also explored. Keywords: Balanced Binary Search, Binary Root Search Strategy, Multi-key Elements, Search Pool, Search Space Reduction, Tiered Binary Search 1. Introduction Binary Search and its variants are studied extensively in Computer Science literature due to efficiency and strong application flavors. A simple, yet powerful application of Binary Search, which may conveniently be used to compute the n-th root of a positive real number is presented. The algorithm is motivational and foundational to the Tiered Binary Search as proposed in this paper. As articulated, binary search has a vast arena of applications both in and out of the Computer Science literature. So research with variations of the basic binary search opened up the Multiple key search paradigm for the author that dates back to 2004 [1]. The concept pertaining to multi-key search strategy through Balanced Binary Search is presented, and the analysis is carried out. A search algorithm need not always be restricted to computing a single key, x inside of a search pool. This implies that advanced search algorithms could be designed that essentially compare between two array elements [1] to identify the relatively smaller key array elements inside the larger key search pool. With that perception, the concept pertaining to multiple key search strategy was introduced by the author to the computing community back in 2004 [1]. One significant improvement with the proposed multi-key search strategy over the traditional binary search is the effective reduction in the search space, which accelerates the key search computation. Additionally, instead of just two variants of the key search strategy, which are searching the key element either in an ascending or in a descending sorted search pool, four different variants are available to compute - which are an ascending key array searched inside of an ascending search pool, an ascending array searched inside a descending search pool, a descending key array searched in a descending search pool or descending keys located in an ascending search pool. This diversity in computational model has contributed to the application paradigm for the multiple key search algorithms proposed over time ( [2], [4], etc.). Multi-element binary search proposed in [1] keeps on computing the key elements in order beginning with the first key in the larger search pool. The proposed Tiered Binary Search employs a Balanced Binary Search strategy. It starts with the middle element inside of the key array. It detects the position of the middle element in the key array in the larger search pool using a recursive version of the binary search algorithm. Next the algorithm confines searching for the key array portion that contains keys larger than the middle key only in the larger portion of the search pool that contains elements larger than the middle key using the same recursive binary search. For the key elements, which are smaller than the middle key, the algorithm confines its search only in that portion of the search pool, which contains elements smaller than the middle key. Therefore, instead of blindly searching for the keys in the key element array in the larger search pool beginning with the first key and proceeding in succession, the algorithm subdivides the key array elements into two halves, and performs search for each half in one half of the search pool using the recursive binary search. Hence, the proposed algorithm performs the key search through a 2 tiered binary search. Essentially, instead of just blindly looking for a single key in the optimized list at each iteration, the algorithm looks for two different sets of keys in two halves of the search pool; thus performing a tiered binary search. Using two partitions, the algorithm implements a balanced binary search strategy. Hence, the proposed algorithm performs a tiered multiple element binary search strategy, which is computationally more efficient. It is also possible to design an n-tiered balanced binary search algorithm, where n 3. For n tiers, the algorithm subdivides the list of key elements into n equal partitions.

2 26 Int'l Conf. Foundations of Computer Science FCS'17 It then computes the middle key K i for two successive partitions, i and i +1 for each i, i =1, 2,...,(n 1). Assume K 1 is the middle key between partitions 1 and 2. Next the algorithm, computes the exact key locations in the search pool (larger array) for each partitioning key K i, i = 1, 2,...,(n 1). Denoting those index locations by v i, i = 1, 2,...,(n 1) at elements E[v i ], the algorithm confines the search for all keys in the key partition, i that are smaller than K i only within the search pool fragment, which contains elements smaller than E[v i ], and larger than E[v i 1 ], which are essentially the elements y, such that E[v i 1 ] <y< E[v i ]. In the first tier, all elements from the search pool are available to perform binary search to detect the partitioning key elements K i, i =1, 2,...,(n 1). However,inthe second tier, only a portion of the larger list (search pool), which are namely the elements from E[v i 1 +1] through E[v i 1] are available to perform the binary search for the keys that lie within the range of K i 1 through K i, exclusive. Hence, the generalized algorithm performs ann- Tiered Binary Search. The paper is organized as follows. Section 2 introduces the terms and notation used in the paper. Section 3 explores formal foundation of the proposed algorithms. Section 4 describes the nth Root Finding Algorithm, which is motivational and foundational to the proposed tiered binary search algorithms. The analysis of the algorithm follows. Section 5 represents the Tiered Binary Search Algorithm. Initially, the 2 key version of the Tiered Binary Search algorithm is presented, which is followed by the more generalized p- partitioning key version. A part of this section is devoted towards analyzing the algorithm. The search space reduction due to tiered binary search is also considered. Section 6 considers tiered binary search variations for possible search key and search pool combinations. 2. Terms and Notation n: Total number of elements in the larger list, known as the Search Pool. m: Number of keys. Here, m 2, and n>m. L 1 : Search Pool with n given elements. L 2 : List containing m different keys. k i : The ith key in the list, L 2, i =1, 2,...,m. r: List size to key size ratio, which is n m.forn>m, n m > 1. t i : Index position of the ith key, k i in the search pool, L 1. Here 1 t i n. Also, 1 i m. left: Index position of the leftmost element in search pool, L 1. right: Index position of the rightmost element in search pool, L 1. l: Denotes the length of a list (search pool) or a search space. p: Denotes number of partitioning keys for the generalized tiered search. Definition 1: Keygap, g: The number of elements between two successive keys, k i and k i+1 in search pool, L 1 is known as the Keygap. Here, i =1, 2,...,(m 1). For instance, the number of elements in between the keys, k j and k j+1 is, t j+1 t j 1. Therefore, the Keygap between these two keys is, g j = t j+1 t j 1 elements. For uniformly distributed keys in the search pool, L 1, Keygap, g (n m) n m 1 throughout the search pool. Definition 2: Inter-Key Space Elements, I: Elements in between all successive pairs of keys is collectively known as the Inter-Key Space Elements (IKSE). This is denoted by I. Therefore, I = m 1 j=1 (t j+1 t j 1). Ifakeyis not identified inside the larger list, L 1, then I measures the number of elements between the first previous existing key within the search pool and the next succeeding key existent within the search pool. If none of the m keys exist within L 1, I = 0. If there is only 1 key, say the jth key, k j that exists in L 1, then I = (n t j ). If only the first key, k 1 and the last key, k m exist within L 1, then I =(t m - t 1 1). If only the hth and the sth keys are in L 1 such that 1 h<s m, then I = t s - t h - 1. Also, I for other key index combinations may be determined analogously. Definition 3: Search Space Improvement Factor, SSIF: It is ratio of the computational search space, C O,if k individualized keys are searched inside the search pool, arr[], one key at a time to the search space, C T explored by the proposed tiered binary search algorithm. Therefore, SSIF = C O C T. In general, SSIF = C O C T >> 1. The higher is the ratio, SSIF, the better efficiency is encountered through the proposed tiered binary search algorithm. 3. Formal Foundation With multiple key binary search strategy, instead of bluntly looking for a single key inside of a larger list, all keys are simultaneously being searched for. This strategy significantly reduces the computational overhead due to the individualized execution of the search algorithm with only one key element. Multi-key tiered binary search provides with a very high yield with sorted list elements, which is a requirement for binary search. With the proposed search algorithm, there are two sets. One set is, S 1, the search pool (the larger list) of distinct elements where the proposed algorithm is being applied to. The other set, S 2 contains the distinct keys that are required to be mapped onto the set, S 1. Using set theoretic notation, S 1 = n and S 2 = m, and n >> m.iff is the mapping function from S 2 to S 1, then {y = f(x) =x y S 1 & x S 2 }. Therefore, here the mapping function f is an Identity Function, I x, which maps each key element from the domain of keys to the identical element in the co-domain of search pool, L 1. The key index domain for the mapping is, Z + {0} for Java or C ++ programming language implementation. The element index co-domain in the search pool for the mapping is, Z + {0} { 1} for programming language implementation. Assuming all key elements from S 2 may be mapped onto the corresponding elements in set, S 1, the m

3 Int'l Conf. Foundations of Computer Science FCS'17 27 Predicate Logic Model for the mapping becomes, x y(x S 2 (y S 1 (y = x))). Therefore, the negation of the logical statement is, x y(x S 2 (y / S 1 (y x))). Again, if x = k j and y = Item tj, then j(j 0 j n (x = k j ) ((y = Item tj ) (y = x)). With distinct keys and list elements, the proposed algorithm essentially performs an One-to-one mapping from the set, S 2 to the set, S 1, provided that all key elements in set, S 2 exists in set, S 1. The mapping is not Onto, as S 1 = n>> S 2 = m. Since both the keys and the list elements are distinct (by assumption), no two keys map onto the same search pool element. Due to the same reason, no key maps onto 2 or more different search pool elements. As the algorithm simply performs a one-to-one mapping, which is not onto, therefore, the problem of Collision due to Hashing does not arise with the proposed tiered binary search model. Following is the complete predicate logic model that takes these constraints into account. x y z k((((z = f(x)) (y = f(x))) (z = y)) (((y = f(x)) (y = f(k))) (x = k)))). Since the multiple element binary search mapping is not Bijective, the inverse mapping function does not exit. Furthermore, assuming all keys from S 2 exist in, L 1, which is represented by the set, S 1, S 2 becomes a proper subset of S 1. With the set theoretic notation, this becomes, S 2 S 1. In that event, S 2 is a member of the Power Set, Ψ of S 1. Stated formally, S 2 Ψ(S 1 ).Ifsome keys from S 2 are not present in L 1, S 2 S 1. In that event, there is a third set, S 3, which is a subset of both S 2 and S 1 that lies at the set intersection of S 2 and S 1. Therefore, S 3 = S 2 S1. Also, (S 3 S 2 ) (S 3 S 1 ). The Relation, R between the sets, S 2 and S 1 is an Equality Relation, which is a subset of the Cartesian Product, S 2 S 1 between the sets. Hence, S 2 RS 1 is such that {(x, y) R x S 2 y S 1 (y = x)}. Also, R S 2 S 1. Here, R is a binary relation between the sets. This relation, R between S 2 and S 1 is Reflexive, Symmetric and Transitive. Therefore, R is an Equivalence Relation. Initially, the proposed algorithm searches through the entire search pool, L 1 containing n different elements to identify the middle key index position, k m 2.As S 1 = n, therefore, there are n possible one-to-one mappings from S 2 to S 1. Once k m 2 is identified at location t m 2, the smallers keys, k 1 through k m 2 1 is searched for only within the subset of S 1 containing (t m 2 1) search pool elements. The larger keys, k m 2 +1 through k m are explored only within the (n t m 2 1) search pool elements. Hence, due to subset reduction, the key search space is reduced, and eventually, gets optimized. Beginning with the nth root finding algorithm as a variation to pure binary search, which gradually reduces the search space to converge the algorithm to the closest nth root, the proposed tiered binary search algorithm is presented as another variation to binary search. 4. Proposed nth Root Finding Algorithm Following is the nth root finding algorithm that is very efficient, and works fine for any non-negative real number. Algorithm nthroot Purpose: This algorithm computes the nth root of a nonnegative real number. The supplied parameters are: a constant PRECISION = , a non-negative real number: x from keyboard, and the value of positive integer n, where n 2. So, n Z +. Here, Z + is the set of positive integers, and Z + = {1, 2, 3,...}. nth Root Finding algorithm computes the nth root of the supplied non-negative real number, x. Require: n Z +, n 2, and x 0. Ensure: Correct value of the nth root of the supplied real number, x is computed. Here, x 0. Input non-negative real number x from keyboard. {May prompt the user to input x with x 0.} while x<0 do Display only non-negative real numbers are allowed. So, re-enter x from keyboard. {The program goes on prompting the user to re-enter a non-negative real number as long as the user does not enter one.} end while a = 1.0 if x = 0 then Display nth root = 0.0 if x = 1 then Display nth root = 1.0 if x<1.0 then b = x while (a b) >PRECISIONdo midp oint = (a + b)/2.0 if midp oint midp oint midp oint...(n times) <xthen b = midp oint a = midp oint end while Display nth root = midp oint b = x while (b a) >PRECISIONdo midp oint = (a + b)/2.0 if midp oint midp oint midp oint...(n times) <xthen a = midp oint b = midp oint end while Display nth root = midp oint

4 28 Int'l Conf. Foundations of Computer Science FCS' nth Root Finding Algorithm Analysis Here, a modified binary search technique is used to assign an estimate of the nth root to a non-negative real number, x to another variable, root. There are four different cases associated with the computational scenario. Case 1: x =0.0. In this case, the nth root of x =0.0. Case 2:In this case x>0.0 and x<1.0. Following are the steps to compute the nth root: Step 1: Since x<1.0, the nth root lies in between 0.0 and x itself. Step 2: Declare 2 real variables a and b. Initialize, a =1.0, and b = x. So, x < root < 1.0. This is n true, as if x<1.0 and x>0.0, x>x. Step 3: Change, or fine tune the double variables a and b, and make them closer and closer to each other by narrowing the root search space. It is necessary to ensure that the root lies in between a and b. Therefore, the invariant for the search is, b root a. Case 3: In this case, x =1.0. Therefore, with this case, n x =1.0. Case 4: In this case, x>1.0. So, the nth root of x must lie in between 1.0 and x itself. Following are the steps involved in computation: Step 1: Declare two variables a and b. Step 2: Assign a =1.0, and b = x. Step 3: Therefore, the nth root must lie between a and b. Change or fine tune a and b, so that a and b get closer and closer to each other to converge to the actual nth root. In this case, the invariant for the computation is, a root b. 5. Proposed Tiered Binary Search Algorithm Following is the proposed Tiered Binary Search algorithm with m keys, where m 2. Following algorithm uses only 1 partitioning key, which is the middle key in the keys[] array. Algorithm T ieredbinarysearchp 1 mkey Purpose: This algorithm performs m-key Tiered Binary Search with only 1 middle key. The supplied parameters are: Search Pool arr[], having n elements where the keys are to be identified. An array of m different keys, keys[]. Assumption: n >> m. m-key Tiered Binary Search returns the array keylocations[] (in Java) with the computed index positions for m different keys. If a key does not exist, the corresponding position in array keylocations[] contains a 1. Require: Both the arrays arr[] and keys[] are required to be sorted. For this algorithm, both arr[] and keys[] are sorted in ascending order. Ensure: Proper key index positions are identified. int[] keylocations = new int[keys.length] {Number of elements in keylocations[] = m = the number of keys in keys[].} startindex = 0 endindex =(arr.length 1) keyfirst = 0; keylast =(keys.length 1) middlekey =(keyfirst + keylast) /2 keylocations[middlekey] = RecursiveBinarySearch(arr, startindex, endindex, keys[middlekey]); {Determine the middlekey key location in the search pool, arr[].} for i=0 to (middlekey 1) do keylocations[i] = RecursiveBinarySearch(arr, startindex, (keylocations[middlekey] 1), keys[i]) {Use a for loop to determine the key index locations in search pool, arr[] for all keys that are smaller than middlekey.} startindex =(keylocations[i]+1) {Shift start position to index next to current key location.} {Next the algorithm performs a Balanced Binary Search for the keys that are larger than the keys[middlekey].} {Beginning with the last key index location, keylast, at each iteration, the value of i is decreased by 1.} for i=keylast to (middlekey +1) do keylocations[i] = RecursiveBinarySearch(arr, (keylocations[middlekey]+1), endindex, keys[i]) endindex =(keylocations[i] 1) {Shift end position to an index immediately before current key index location.} return keylocations {Return the Java array, keylocations[] containing the m key index positions to the calling program.} A more generalized version as discussed in the following uses k partitioning keys, where k 2. Algorithm T ieredbinarysearchp k mkey Purpose: This algorithm performs m-key Tiered Binary Search with k partitioning keys. The supplied parameters are: Search pool array arr[], having n elements where the keys are to be identified. An array of m different keys, keys[]. Assumption: n >> m. Also, an integer k 2. k determines the number of Partitioning Keys. m-key Tiered Binary Search returns the array keylocations[] (in Java) with the identified index positions of m different keys.

5 Int'l Conf. Foundations of Computer Science FCS'17 29 If a key does not exist, the corresponding key position in array, keylocations[] contains a 1. Require: Both the arrays arr[] and keys[] are required to be sorted. For this algorithm, both arr[] and keys[] are sorted in ascending order. Ensure: Proper key index positions are identified. int[] keylocations = new int[keys.length] {Number of elements in keylocations[] = m = the number of keys in keys[].} int[] keyp artitions = new int[k] {The array to hold the partitioning keys.} int[] partitionindices = new int[k] {partitionindices[] holds the indices of the Partitioning Keys.} startindex = 0 endindex =(arr.length 1) keyfirst = 0; keylast =(keys.length 1) for i=0 to (k 1) do keyp artitions[i] = keys[int(((keylast) / (k + 1)) (i +1))] {Determine each partitioning key in keys[] array, and load it to the corresponding index location in keyp artitions[] array.} partitionindices[i] =int(((keylast) /(k +1)) (i + 1)) {Hold the indices of Partitioning Keys in partitionindices[] array.} keylocations[int(((keylast) /(k +1)) (i +1))] = RecursiveBinarySearch(arr, startindex, endindex, keyp artitions[i]) {Determine the keyp artitions[i] key location in the larger array, arr[].} startindex =(int(((keylast) /(k +1)) (i +1))) + 1 {Shift the start position for the next Partitioning key.} startindex = 0 {The beginning index for key search in the search pool array, arr[].} for i=0 to (k-1) do if i == 0 then indexleft = 0 {Define indexleft as the left index for the current sub-interval inside the key array, keys[]} indexleft = partitionindices[(i 1)]+1 if i<k-1 then indexright = partitionindices[i]-1 {Define indexright as the right index for the current sub-interval in key array, keys[]} indexright =(keys.length 1) {For the last interval, the end interval for the keys array, is the length of keys[] 1.} indexmiddle = int((indexleft + indexright)/2) {Define indexmiddle as the middle index for the current sub-interval in key array, keys[]} keylocations[indexmiddle] = RecursiveBinarySearch(arr, startindex, keylocations[partitionindices[i]-1, keys[indexmiddle]) {Determine the key index location for the key at indexmiddle inside the search pool, arr[]} {Next apply Binary Search to the keys within the range of indexleft and (indexmiddle - 1)} for j=indexleft to (indexmiddle - 1) do keylocations[j] = RecursiveBinarySearch(arr, startindex, (keylocations[indexmiddle]-1), keys[j]) {Use a for loop to determine the key index locations in search pool, arr[] for all keys that are smaller than keys[indexmiddle].} startindex =(keylocations[j]+1) {Shift start index position to 1 index position right to current key index location, keylocations[j].} {This strategy significantly reduces the key index search space.} {Next the algorithm performs a Balanced Binary Search for the keys that are larger than keys[indexmiddle].} startindex = keylocations[indexmiddle] + 1 {Adjust the beginning index for key search inside the search pool, arr[] one position right to keylocations[indexmiddle].} if i == (k-1) then endindex =(arr.length 1) {For the last interval, set endindex to length of arr[] array - 1.} endindex = keylocations[partitionindices[i]]-1 {Adjust the ending index for search interval inside the search pool, arr[] to one position left of the key partitioning index.} for j=indexright to (indexmiddle + 1) do keylocations[j] = RecursiveBinarySearch(arr, startindex, endindex, keys[j]) endindex = (keylocations[j]-1) {Shift the end position in the search pool, arr[] to an index value immediately before the current key location.} startindex = keylocations[partitionindices[i] +1 {Adjust the starting interval for key search inside the search pool, arr[] one position to the right of the end of current search interval in arr[].} return keylocations {Return the Java array, keylocations[] containing m key index positions to the calling program.}

6 30 Int'l Conf. Foundations of Computer Science FCS' Algorithm Analysis The proposed multiple element tiered binary search algorithm performs a balanced nested range-based binary search to optimize the key search space, and hence, improves the search efficiency. This is essentially a list-to-list mapping, where the smaller list has m elements and the larger list, which is the search pool has n elements. Here, m, n Z +. Nested tiered binary search provides with better time and space efficiency. Also, the proposed algorithm balances the computation by performing a balanced binary search. With the simpler 1 partitioning key version, the algorithm finds the middle element in the key array. Here, middle_key_index = m 2. Next, the algorithm performs binary search to find the exact key index location for k middle_key_index inside the search pool, arr[n]. Suppose, k middle_key_index was identified at index position p inside the array, arr[n]. If k middle_key_index does not exist inside, arr[n], the proposed algorithm records the last index before left_index > right_index for the search following through the binary search strategy. Next, the algorithm confines the search for the key elements from index 0 through (middle_key_index-1) inside the sub-array of array, arr[] from arr[0] through arr[p 1], and confines the search for the key elements beginning at index (middle_key_index+1) through m within the subarray, arr[p +1] through arr[n 1] (as index begins at 0). Example 4 (Search Space Optimization): Consider a list, L 1 containing 10 6 elements, and a list, L 2 of keys with 10 3 elements. Then the middle key for L 2 lies at index 499 (assuming indexing begins at 0 and goes up until 999). The middle key will be searched in the space of 10 6 elements. So the binary searches performed will be c log 2 (10 6 ) = c log 10 (10 6 ) log 2 (10). But log 2 (10) is a constant. Denote log 2 (10) by acutec, and c acutec by C. Then the number of searches for the middle partitioning key is 6C. Without partitioning, applying the basic binary search for all 10 3 keys in L 2, the number of searches will be C = 6000C, C is the constant for binary search. With only one partitioning middle key, assume for simplicity, that the keys are uniformly distributed inside the search pool L 1. Then the middle key will be identified half-way at L 1, which is at index So, search for the keys at index 0 through index 498 will be confined only to the elements at index 0 through index For the first element, it will be searched through a space of 499, 999 elements 500, 000. The second element will be searched over a space of 498, , 000 elements, and so. As the list is uniformly distributed, the last element in the first half will be searched through a space of approximately, 2000 elements. So the total search space size is , 750, 000 elements. So the binary search performed will be c log 2 ( ) = C log 10 ( ) 8.1C. Since this is balanced binary search, the algorithm performs another 8.1C binary searches for the keys at index 500 through 999. So the binary search required is (( C) = 16.2C. With the assumption, the search space reduces by a factor of 6000C 16.2C = So, the search space improvement factor, SSIF = Hence, the effective search space may significantly be reduced through the enhanced k-partitioning key version using the proposed multiple key tiered binary search algorithm. 6. Search Variations As articulated before, the nth Root Finding Algorithm is motivational and foundational to the proposed tiered binary search in gradually narrowing down the search space. With different combinations of elements in L 1 and L 2, four optimum search strategies are possible as variations to the proposed algorithm. These are precisely described below. Here, both L 1 and L 2 are sorted. Combination 1: Consider when both L 1 and L 2 are sorted in ascending order. This combination is the most common, and is used throughout this paper. Assume that the middle key, k middle is identified at index t middle with a single partitioning key. So the keys smaller than this partitioning key are searched only within the sub-array, arr[0] through arr[t i 1]. Once a key, k i is identified at index position, t i, the leftmost index is shifted right to t i +1 for this sub-list. The rightmost index remains at its original position. For balanced binary search, keys larger than k middle is searched within the sub-array, arr[t i +1]] through arr[n 1], beginning with the largest key at k (m 1). Once it is identified at index t (m 1), the rightmost index is shifted left to t (m 1) 1 for this sublist. Hence, both left and right index positions are gradually shifted towards the partitioning index, gradually narrowing down the converging search space. Hence, the overall search space is optimized. Combination 2: Consider when L 1 is in ascending order and L 2 is in descending order. Therefore, the keys in L 2 are organized from higher to lower order. Assume that the middle key, k middle is identified at index t middle with a single partitioning key. So, keys smaller than the partitioning key that are located in the right half of the key array are searched only within the sub-array, arr[0] through arr[t i 1] beginning with the smallest key or the last key at k (m 1). Once a key, k i is identified at index position, t i, the rightmost index is shifted left to t i 1 for this sub-list. The leftmost index remains at its original position. As the proposed algorithm performs a balanced binary search, the keys larger than k middle, which are inside the left half of the list are searched only within the sub-array, arr[t i +1] through arr[n 1], beginning with the largest key at k 0. Once it is identified at index location t 0, the leftmost index is shifted left to t 0 +1 for this sublist. Hence, both the left and the right index positions are gradually narrowed down towards the partitioning index, squeezing the key search space.

7 Int'l Conf. Foundations of Computer Science FCS'17 31 Combination 3: Here, both L 1 and L 2 are in descending order. This combination works pretty similarly to that in Combination 1. Assume that the middle key, k middle is identified at index t middle with a single partitioning key. So the keys larger than this partitioning key are searched only within the search pool, arr[0] through arr[t i 1]. Once a key, k i is identified at index position, t i, the leftmost index is shifted right to t i +1 for this sub-list. The rightmost index remains at its original position. As the proposed algorithm performs a balanced binary search, the keys smaller than k middle are searched for only within the sub-array, arr[t i +1] through arr[n 1], beginning with the smallest key at k (m 1). Once it is identified at index location t (m 1), the rightmost index is shifted left to t (m 1) 1 for this sublist. Hence, both left and right index positions are gradually shifted towards the partitioning index, optimizing the key search space. Combination 4: With this combination, L 1 is in descending order and L 2 is in ascending order. Therefore, the keys in L 2 are organized from lower to higher order. Assume that the middle key, k middle is identified at index t middle with only 1 partitioning key. So the keys smaller than the partitioning key that are located within the left half of the key array are searched only within the sub-array, arr[t i +1] through arr[n 1] beginning with smallest key or the first key at k 0. Once a key, k i is identified at index position, t i, the rightmost index is shifted left to t i 1 for this sub-list. The leftmost index remains at its original position. As the proposed algorithm performs a balanced binary search, the keys larger than k middle, which are located in the right half of the keys array are searched for only within the sub-array, arr[0] through arr[t i 1], beginning with the largest key at k (m 1). Once it is identified at index location t (m 1), the leftmost index is shifted right to t (m 1) +1 for this sublist. Hence, both left and right index positions are gradually shifted narrowing down the overall key search space. Hence, the overall search space is optimized by shifting the boundaries towards the middle key index position. This is the beauty of the proposed computational algorithm in this paper. 7. Conclusion and Future Research This paper proposes a new algorithm for range-based tiered multiple element binary search strategy, and shows the effectiveness of the proposed algorithm in search space reduction. The paper also explores a formal foundation to the proposed algorithm. Examples are incorporated to illustrate the concepts introduced. In future, to demonstrate the overall computational effectiveness of the proposed algorithm, following computation time measurements will be carried out: Both the Search Pool (the larger array) and the Keys are Sorted in Ascending Order. Both the Search Pool and the Keys are Sorted in Descending Order. The Search Pool is Sorted in Ascending Order and the Keys are Sorted in Descending Order. The Search Pool is Sorted in Descending Order and the Keys are Sorted in Ascending Order. Computation times for the above 4 combinations will be compared to each other through graphical as well as tabular means. As per as the computational mechanics is concerned, following will be implemented for algorithmic computation. Beginning with the index position calculated for the middle key in search pool, the left half of the search pool will be searched in ascending order, and right half of the search pool will be searched in descending order of keys. Beginning with the index position computed for the middle key in search pool, the left half of the search pool will be searched in descending order, and right half of the search pool will be searched in ascending order of keys. Beginning with the index position calculated for the middle key in search pool, both the search pool halves will be searched with descending order of keys. Beginning with the index position calculated for the middle key in search pool, both the search pool halves will be searched with ascending order of keys. Binary search is popular due to its logarithmic efficiency, and the strong application flavor. One of the most important future works will be to research out a significant application of the proposed tiered binary search algorithm. In future, the algorithm will be implemented for different key and list order combinations, as outlined above. The related algorithmic performances will be evaluated, and compared to each other. Other performance issues will also be considered in details. References [1] A. Tarek, "A Logarithmic Algorithm for Multi-Key Binary Search," in Proc. SCI 04, 2004, vol. II, pp [2] A. Tarek, "A New Approach for Multiple Element Binary Search in Database Applications," NAUN INTERNATIONAL JOURNAL OF COMPUTERS, vol. 1, pp , Issue 4, [3] A. Tarek, "Multi-key Binary Search and the Related Performance," in Proc. WSEAS American Conference on Applied Mathematics, University of HARVARD, Cambridge, 2008, pp [4] A. Tarek, "A New Algorithm for Multiple Key Interpolation Search in Uniform List of Numbers," Recent Advances in Applied Mathematics and Computational and Information Sciences, vol. II, [5] A. Tarek, "A New Algorithm for Multiple Key Linear Interpolation with the Formal Foundation," in Proc. CSC 14, 2014, paper CSC2003.