searching and sorting organized

Author: Mari Wahl

src/searching_and_sorting/binary_search.py

@@ -1,49 +1,56 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "[email protected]"
+__author__ = "bt3"
 
 
 
-def binary_search(seq, key):
-    ''' binary search iterative algorithm '''
-    ''' observe that the index is returned '''
-    hi = len(seq)
+def binary_search_rec(array, item, lo=0, hi = None):
+    '''
+    >>> binary_search_rec([2,3,5,6,8,10,15,23], 15)
+    (True, 6)
+    >>> binary_search_rec([2,3,5,6,8,10,15,23], 4)
+    False
+    '''
+    hi = hi or len(array)
+    if hi < lo :
+        return False
+
+    mid = (hi + lo)//2
+
+    if array[mid] == item:
+        return True, mid
+    elif array[mid] < item:
+        return binary_search_rec(array, item, mid + 1, hi)
+    else:
+        return binary_search_rec(array[:mid], item, lo, mid -1)
+
+
+
+def binary_search_iter(array, item):
+    '''
+    >>> binary_search_iter([2,3,5,6,8,10,15,23], 15)
+    (True, 6)
+    >>> binary_search_iter([2,3,5,6,8,10,15,23], 4)
+    False
+    '''
+    hi = len(array)
     lo = 0
+
     while lo < hi:
-        mid = (hi+lo) // 2
-        if seq[mid] == key:
-            return mid
-        elif key < seq[mid]:
+        mid = (hi+lo)//2
+        if array[mid] == item:
+            return True, mid
+        elif array[mid] > item:
             hi = mid
         else:
-            lo = mid + 1
-
-
-def binary_search_rec(seq, key, lo=0, hi=None):
-    ''' binary search recursive algorithm '''
-    hi = hi or len(seq)
-    if hi < lo: return None
-    mid = (hi + lo) // 2
-    if seq[mid] == key:
-        return mid
-    elif seq[mid] < key:
-        return binary_search_rec(seq, key, mid + 1, hi)
-    else:
-        return binary_search_rec(seq, key, lo, mid - 1)
-
+            lo  = mid + 1
+    return False
 
-def test_binary_search():
-    seq = [1,2,5,6,7,10,12,12,14,15]
-    key = 6
-    assert(binary_search(seq, key) == 3)
-    assert(binary_search_rec(seq, key) == 3)
-    print('Tests passed!')
 
 
-if __name__ == '__main__':
-    test_binary_search()
-
 
 
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
 

src/searching_and_sorting/quick_sort.py

@@ -1,75 +1,89 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "[email protected]"
+__author__ = "bt3"
 
 
-''' Searches an element in a matrix where in every row, the values are increasing from left to right, but the last number in a row is smaller than the first number in the next row.
-
-    (1) The naive brute force solution (sequential search)  scan all numbers and cost O(nm).  However, since the numbers are already sorted, the matrix can be viewed as a 1D sorted array.  The binary search algorithm is suitable. The efficiency is O(logmn).
-
+def binary_search_matrix_rec(m, key, lo=0, hi=None):
+    '''
     >>> m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
     >>> binary_search_matrix_rec(m, 6)
     (1, 2)
     >>> binary_search_matrix_rec(m, 12)
-    >>> binary_search_matrix_iter(m, 6)
-    (1, 2)
-    >>> binary_search_matrix_iter(m, 12)
-    >>> binary_search_matrix_iter(m, 1)
-    (0, 0)
-
-    (2) Another solution is "discarding" arrays in the way. The efficiency is O(logm).
-    >>> m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
-    >>> searching_matrix(m, 6)
-    (1, 2)
-    >>> searching_matrix(m, 12)
-
-'''
-
+    '''
+    if not m:
+        return None
 
-def binary_search_matrix_rec(m, key, lo=0, hi=None):
-    if not m: return None
     rows = len(m)
     cols = len(m[0])
     hi = hi or rows*cols
-    if hi > lo: # -----> REMEMBER THIS OR INDEX WILL EXPLODE!!!!!!!!
+
+    if hi > lo:
+
         mid = (hi + lo)//2
         row = mid//cols
         col = mid%cols
         item = m[row][col]
-        if key == item: return row, col
-        elif key < item: return binary_search_matrix_rec(m, key, lo, mid-1)
-        else: return binary_search_matrix_rec(m, key, mid+1, hi)
+
+        if key == item:
+            return row, col
+        elif key < item:
+            return binary_search_matrix_rec(m, key, lo, mid-1)
+        else:
+            return binary_search_matrix_rec(m, key, mid+1, hi)
+
     return None
 
 
 
 def binary_search_matrix_iter(m, key):
-    if not m: return None
+    '''
+
+    '''
+
+    if not m:
+        return None
     rows = len(m)
     cols = len(m[0])
     lo, hi = 0, rows*cols
+
     while lo < hi:
         mid = (hi + lo)//2
         row = mid//rows
         col = mid%rows
         item = m[row][col]
-        if key == item: return (row, col)
-        elif key < item: hi = mid
-        else: lo = mid +1
+        if key == item:
+            return (row, col)
+        elif key < item:
+            hi = mid
+        else:
+            lo = mid +1
+
     return None
 
 
 def searching_matrix(m, key):
-    if not m: return None
+    '''
+    >>> m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    >>> searching_matrix(m, 6)
+    (1, 2)
+    >>> searching_matrix(m, 12)
+    '''
+
+    if not m:
+        return None
     rows = len(m)
     cols = len(m[0])
     i, j = 0, cols -1
+
     while i < rows and j > 0:
         item = m[i][j]
-        if key == item: return (i, j)
-        elif key < item: j -= 1
-        else: i += 1
+        if key == item:
+            return (i, j)
+        elif key < item:
+            j -= 1
+        else:
+            i += 1
+
     return None
 
 

src/searching_and_sorting/searching/binary_search.py

@@ -1,21 +1,27 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
-__author__ = "Mari Wahl"
-__email__ = "[email protected]"
+__author__ = "bt3"
 
 
 
-''' Given a sorted array that was rotated, find an item with binary search:
+'''
+Given a sorted array that was rotated, find an item with binary search:
 '''
 
 def find_element_rot_array(seq, key, lo=0, hi=None):
+
     hi = hi or len(seq)
-    if hi <= lo: return None # base case: <= for odd and even numbers!
+    if hi <= lo:
+        return None # base case: <= for odd and even numbers!
+
     mid = (hi + lo) // 2
-    if key == seq[mid]: return mid
+
+    if key == seq[mid]:
+        return mid
 
     # if left is ordered --> we work here
     if seq[lo] <= seq[mid]:
+
         # now, is the key there?
         if key < seq[mid] and key >= seq[lo]:
             return find_element_rot_array(seq, key, lo, mid)
@@ -25,6 +31,7 @@ def find_element_rot_array(seq, key, lo=0, hi=None):
 
     # right is ordered --> we work here
     else:
+
         # now, is the key there?
         if key > seq[mid] and key <= seq[hi-1]: # stupid hi-1!!!
             return find_element_rot_array(seq, key, mid+1, hi)

src/searching_and_sorting/searching/binary_search_matrix.py

@@ -1,22 +1,23 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "[email protected]"
-
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
 def find_max_unimodal_array(A):
-    if len(A) <= 2 : return None
+    if len(A) <= 2 :
+        return None
     left = 0
     right = len(A)-1
+
     while right > left +1:
+
         mid = (left + right)//2
         if A[mid] > A[mid-1] and A[mid] > A[mid+1]:
             return A[mid]
         elif A[mid] > A[mid-1] and A[mid] < A[mid+1]:
             left = mid
         else:
             right = mid
+
     return None
 
 

src/searching_and_sorting/searching/find_item_rotated_sorted_array.py

@@ -1,14 +1,11 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "[email protected]"
-
+#!/usr/bin/env python
 
+__author__ = "bt3"
 
+''' implement square root using binary search '''
 
 
 def find_sqrt_bin_search(n, error=0.001):
-    ''' implement square root using binary search '''
     lower = n < 1 and n or 1
     upper = n < 1 and 1 or n
     mid = lower + (upper - lower) / 2.0