Interpolation search - fix endless loop bug, divide 0 bug and update description (TheAlgorithms#793)

* fix endless loop bug, divide 0 bug and update description fix an endless bug, for example, if collection = [10,30,40,45,50,66,77,93], item = 67. fix divide 0 bug, when right=left it is not OK to point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left]) update 'sorted' to 'ascending sorted' in description to avoid confusion * delete swap files * delete 'address' and add input validation

Author: weixuanhu

searches/interpolation_search.py

@@ -11,16 +11,23 @@
 
 definterpolation_search(sorted_collection, item):
 """Pure implementation of interpolation search algorithm in Python
- Be careful collection must be sorted, otherwise result will be
+ Be careful collection must be ascending sorted, otherwise result will be
  unpredictable
- :param sorted_collection: some sorted collection with comparable items
+ :param sorted_collection: some ascending sorted collection with comparable items
  :param item: item value to search
  :return: index of found item or None if item is not found
  """
 left=0
 right=len(sorted_collection) -1
 
 whileleft<=right:
+#avoid devided by 0 during interpolation
+ifsorted_collection[left]==sorted_collection[right]:
+ifsorted_collection[left]==item:
+returnleft
+else:
+returnNone
+
 point=left+ ((item-sorted_collection[left]) * (right-left)) // (sorted_collection[right] -sorted_collection[left])
 
 #out of range check
@@ -31,66 +38,97 @@ def interpolation_search(sorted_collection, item):
 ifcurrent_item==item:
 returnpoint
 else:
-ifitem<current_item:
-right=point-1
-else:
-left=point+1
+ifpoint<left:
+right=left
+left=point
+elifpoint>right:
+left=right
+right=point
+else: 
+ifitem<current_item:
+right=point-1
+else:
+left=point+1
 returnNone
 
-
 definterpolation_search_by_recursion(sorted_collection, item, left, right):
 
 """Pure implementation of interpolation search algorithm in Python by recursion
- Be careful collection must be sorted, otherwise result will be
+ Be careful collection must be ascending sorted, otherwise result will be
  unpredictable
  First recursion should be started with left=0 and right=(len(sorted_collection)-1)
- :param sorted_collection: some sorted collection with comparable items
+ :param sorted_collection: some ascending sorted collection with comparable items
  :param item: item value to search
  :return: index of found item or None if item is not found
  """
-point=left+ ((item-sorted_collection[left]) * (right-left)) // (sorted_collection[right] -sorted_collection[left])
 
+#avoid devided by 0 during interpolation
+ifsorted_collection[left]==sorted_collection[right]:
+ifsorted_collection[left]==item:
+returnleft
+else:
+returnNone
+
+point=left+ ((item-sorted_collection[left]) * (right-left)) // (sorted_collection[right] -sorted_collection[left])
+
 #out of range check
 ifpoint<0orpoint>=len(sorted_collection):
 returnNone
 
 ifsorted_collection[point] ==item:
 returnpoint
-elifsorted_collection[point] >item:
-returninterpolation_search_by_recursion(sorted_collection, item, left, point-1)
+elifpoint<left:
+returninterpolation_search_by_recursion(sorted_collection, item, point, left)
+elifpoint>right:
+returninterpolation_search_by_recursion(sorted_collection, item, right, left)
 else:
-returninterpolation_search_by_recursion(sorted_collection, item, point+1, right)
+ifsorted_collection[point] >item:
+returninterpolation_search_by_recursion(sorted_collection, item, left, point-1)
+else:
+returninterpolation_search_by_recursion(sorted_collection, item, point+1, right)
 
 def__assert_sorted(collection):
-"""Check if collection is sorted, if not - raises :py:class:`ValueError`
+"""Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
  :param collection: collection
- :return: True if collection is sorted
- :raise: :py:class:`ValueError` if collection is not sorted
+ :return: True if collection is ascending sorted
+ :raise: :py:class:`ValueError` if collection is not ascending sorted
  Examples:
  >>> __assert_sorted([0, 1, 2, 4])
  True
  >>> __assert_sorted([10, -1, 5])
  Traceback (most recent call last):
  ...
- ValueError: Collection must be sorted
+ ValueError: Collection must be ascending sorted
  """
 ifcollection!=sorted(collection):
-raiseValueError('Collection must be sorted')
+raiseValueError('Collection must be ascending sorted')
 returnTrue
 
 
 if__name__=='__main__':
 importsys
-
-user_input=raw_input('Enter numbers separated by comma:\n').strip()
+
+"""
+ user_input = raw_input('Enter numbers separated by comma:\n').strip()
  collection = [int(item) for item in user_input.split(',')]
  try:
  __assert_sorted(collection)
  except ValueError:
-sys.exit('Sequence must be sorted to apply interpolation search')
+ sys.exit('Sequence must be ascending sorted to apply interpolation search')
 
  target_input = raw_input('Enter a single number to be found in the list:\n')
  target = int(target_input)
+ """
+
+debug=0
+ifdebug==1:
+collection= [10,30,40,45,50,66,77,93]
+try:
+__assert_sorted(collection)
+exceptValueError:
+sys.exit('Sequence must be ascending sorted to apply interpolation search')
+target=67
+
 result=interpolation_search(collection, target)
 ifresultisnotNone:
 print('{} found at positions:{}'.format(target, result))

searches/quick_select.py

@@ -14,16 +14,21 @@ def _partition(data, pivot):
  """
 less, equal, greater= [], [], []
 forelementindata:
-ifelement.address<pivot.address:
+ifelement<pivot:
 less.append(element)
-elifelement.address>pivot.address:
+elifelement>pivot:
 greater.append(element)
 else:
 equal.append(element)
 returnless, equal, greater
 
 defquickSelect(list, k):
 #k = len(list) // 2 when trying to find the median (index that value would be when list is sorted)
+
+#invalid input
+ifk>=len(list) ork<0:
+returnNone
+
 smaller= []
 larger= []
 pivot=random.randint(0, len(list) -1)
@@ -41,4 +46,4 @@ def quickSelect(list, k):
 returnquickSelect(smaller, k)
 #must be in larger
 else:
-returnquickSelect(larger, k- (m+count))
+returnquickSelect(larger, k- (m+count))

searches/test_interpolation_search.py

@@ -0,0 +1,93 @@
+importunittest
+frominterpolation_searchimportinterpolation_search, interpolation_search_by_recursion
+
+classTest_interpolation_search(unittest.TestCase):
+defsetUp(self):
+# un-sorted case
+self.collection1= [5,3,4,6,7]
+self.item1=4
+# sorted case, result exists
+self.collection2= [10,30,40,45,50,66,77,93]
+self.item2=66
+# sorted case, result doesn't exist
+self.collection3= [10,30,40,45,50,66,77,93]
+self.item3=67
+# equal elements case, result exists
+self.collection4= [10,10,10,10,10]
+self.item4=10
+# equal elements case, result doesn't exist
+self.collection5= [10,10,10,10,10]
+self.item5=3
+# 1 element case, result exists
+self.collection6= [10]
+self.item6=10
+# 1 element case, result doesn't exists
+self.collection7= [10]
+self.item7=1
+
+deftearDown(self):
+pass
+
+deftest_interpolation_search(self):
+self.assertEqual(interpolation_search(self.collection1, self.item1), None)
+
+self.assertEqual(interpolation_search(self.collection2, self.item2), self.collection2.index(self.item2))
+
+self.assertEqual(interpolation_search(self.collection3, self.item3), None)
+
+self.assertEqual(interpolation_search(self.collection4, self.item4), self.collection4.index(self.item4))
+
+self.assertEqual(interpolation_search(self.collection5, self.item5), None)
+
+self.assertEqual(interpolation_search(self.collection6, self.item6), self.collection6.index(self.item6))
+
+self.assertEqual(interpolation_search(self.collection7, self.item7), None)
+
+
+
+classTest_interpolation_search_by_recursion(unittest.TestCase):
+defsetUp(self):
+# un-sorted case
+self.collection1= [5,3,4,6,7]
+self.item1=4
+# sorted case, result exists
+self.collection2= [10,30,40,45,50,66,77,93]
+self.item2=66
+# sorted case, result doesn't exist
+self.collection3= [10,30,40,45,50,66,77,93]
+self.item3=67
+# equal elements case, result exists
+self.collection4= [10,10,10,10,10]
+self.item4=10
+# equal elements case, result doesn't exist
+self.collection5= [10,10,10,10,10]
+self.item5=3
+# 1 element case, result exists
+self.collection6= [10]
+self.item6=10
+# 1 element case, result doesn't exists
+self.collection7= [10]
+self.item7=1
+
+deftearDown(self):
+pass
+
+deftest_interpolation_search_by_recursion(self):
+self.assertEqual(interpolation_search_by_recursion(self.collection1, self.item1, 0, len(self.collection1)-1), None)
+
+self.assertEqual(interpolation_search_by_recursion(self.collection2, self.item2, 0, len(self.collection2)-1), self.collection2.index(self.item2))
+
+self.assertEqual(interpolation_search_by_recursion(self.collection3, self.item3, 0, len(self.collection3)-1), None)
+
+self.assertEqual(interpolation_search_by_recursion(self.collection4, self.item4, 0, len(self.collection4)-1), self.collection4.index(self.item4))
+
+self.assertEqual(interpolation_search_by_recursion(self.collection5, self.item5, 0, len(self.collection5)-1), None)
+
+self.assertEqual(interpolation_search_by_recursion(self.collection6, self.item6, 0, len(self.collection6)-1), self.collection6.index(self.item6))
+
+self.assertEqual(interpolation_search_by_recursion(self.collection7, self.item7, 0, len(self.collection7)-1), None)
+
+
+
+if__name__=='__main__':
+unittest.main()