Add Interpolation Search.

Author: trekhleb

README.md

@@ -86,6 +86,7 @@ a set of rules that precisely define a sequence of operations.
 *`B`[Linear Search](src/algorithms/search/linear-search)
 *`B`[Jump Search](src/algorithms/search/jump-search) (or Block Search) - search in sorted array
 *`B`[Binary Search](src/algorithms/search/binary-search) - search in sorted array
+*`B`[Interpolation Search](src/algorithms/search/interpolation-search) - search in uniformly distributed sorted array
 ***Sorting**
 *`B`[Bubble Sort](src/algorithms/sorting/bubble-sort)
 *`B`[Selection Sort](src/algorithms/sorting/selection-sort)

src/algorithms/search/interpolation-search/README.md

@@ -0,0 +1,40 @@
+# Interpolation Search
+
+**Interpolation search** is an algorithm for searching for a key in an array that 
+has been ordered by numerical values assigned to the keys (key values).
+
+For example we have a sorted array of `n` uniformly distributed values `arr[]`, 
+and we need to write a function to search for a particular element `x` in the array.
+
+**Linear Search** finds the element in `O(n)` time, **Jump Search** takes `O(√ n)` time 
+and **Binary Search** take `O(Log n)` time.
+
+The **Interpolation Search** is an improvement over Binary Search for instances, 
+where the values in a sorted array are _uniformly_ distributed. Binary Search 
+always goes to the middle element to check. On the other hand, interpolation 
+search may go to different locations according to the value of the key being 
+searched. For example, if the value of the key is closer to the last element, 
+interpolation search is likely to start search toward the end side.
+
+To find the position to be searched, it uses following formula:
+
+```
+// The idea of formula is to return higher value of pos
+// when element to be searched is closer to arr[hi]. And
+// smaller value when closer to arr[lo]
+pos = lo + ((x - arr[lo]) * (hi - lo) / (arr[hi] - arr[Lo]))
+
+arr[] - Array where elements need to be searched
+x - Element to be searched
+lo - Starting index in arr[]
+hi - Ending index in arr[]
+```
+
+## Complexity
+
+**Time complexity**: `O(log(log(n))`
+
+## References
+
+-[GeeksForGeeks](https://www.geeksforgeeks.org/interpolation-search/)
+-[Wikipedia](https://en.wikipedia.org/wiki/Interpolation_search)

src/algorithms/search/interpolation-search/__test__/interpolationSearch.test.js

@@ -0,0 +1,24 @@
+importinterpolationSearchfrom'../interpolationSearch';
+
+describe('interpolationSearch',()=>{
+it('should search elements in sorted array of numbers',()=>{
+expect(interpolationSearch([],1)).toBe(-1);
+expect(interpolationSearch([1],1)).toBe(0);
+expect(interpolationSearch([1],0)).toBe(-1);
+expect(interpolationSearch([1,1],1)).toBe(0);
+expect(interpolationSearch([1,2],1)).toBe(0);
+expect(interpolationSearch([1,2],2)).toBe(1);
+expect(interpolationSearch([10,20,30,40,50],40)).toBe(3);
+expect(interpolationSearch([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],14)).toBe(13);
+expect(interpolationSearch([1,6,7,8,12,13,14,19,21,23,24,24,24,300],24)).toBe(10);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],600)).toBe(-1);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],1)).toBe(0);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],2)).toBe(1);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],3)).toBe(2);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],700)).toBe(3);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,1900],800)).toBe(4);
+expect(interpolationSearch([0,2,3,700,800,1200,1300,1400,1900],1200)).toBe(5);
+expect(interpolationSearch([1,2,3,700,800,1200,1300,1400,19000],800)).toBe(4);
+expect(interpolationSearch([0,10,11,12,13,14,15],10)).toBe(1);
+});
+});

src/algorithms/search/interpolation-search/interpolationSearch.js

@@ -0,0 +1,52 @@
+/**
+ * Interpolation search implementation.
+ *
+ * @param{*[]} sortedArray - sorted array with uniformly distributed values
+ * @param{*} seekElement
+ * @return{number}
+ */
+exportdefaultfunctioninterpolationSearch(sortedArray,seekElement){
+letleftIndex=0;
+letrightIndex=sortedArray.length-1;
+
+while(leftIndex<=rightIndex){
+constrangeDelta=sortedArray[rightIndex]-sortedArray[leftIndex];
+constindexDelta=rightIndex-leftIndex;
+constvalueDelta=seekElement-sortedArray[leftIndex];
+
+// If valueDelta is less then zero it means that there is no seek element
+// exists in array since the lowest element from the range is already higher
+// then seek element.
+if(valueDelta<0){
+return-1;
+}
+
+// If range delta is zero then subarray contains all the same numbers
+// and thus there is nothing to search for unless this range is all
+// consists of seek number.
+if(!rangeDelta){
+// By doing this we're also avoiding division by zero while
+// calculating the middleIndex later.
+returnsortedArray[leftIndex]===seekElement ? leftIndex : -1;
+}
+
+// Do interpolation of the middle index.
+constmiddleIndex=leftIndex+Math.floor(valueDelta*indexDelta/rangeDelta);
+
+// If we've found the element just return its position.
+if(sortedArray[middleIndex]===seekElement){
+returnmiddleIndex;
+}
+
+// Decide which half to choose for seeking next: left or right one.
+if(sortedArray[middleIndex]<seekElement){
+// Go to the right half of the array.
+leftIndex=middleIndex+1;
+}else{
+// Go to the left half of the array.
+rightIndex=middleIndex-1;
+}
+}
+
+return-1;
+}

src/algorithms/search/jump-search/README.md

@@ -23,5 +23,5 @@ minimum when `m = √n`. Therefore, the best step size is `m = √n`.
 
 ## References
 
--[Wikipedia](https://en.wikipedia.org/wiki/Jump_search)
 -[GeeksForGeeks](https://www.geeksforgeeks.org/jump-search/)
+-[Wikipedia](https://en.wikipedia.org/wiki/Jump_search)

src/algorithms/search/jump-search/jumpSearch.js

@@ -3,7 +3,7 @@ import Comparator from '../../../utils/comparator/Comparator'
 /**
  * Jump (block) search implementation.
  *
- * @param{*[]} sortedArray.
+ * @param{*[]} sortedArray
  * @param{*} seekElement
  * @param{function(a, b)} [comparatorCallback]
  * @return{number}