Initial code dump.

Author: Ryan Pon

bubble_sort.py

@@ -0,0 +1,41 @@
+"""
+A practice implementation of bubble sort.
+"""
+
+def non_increasing(a, b):
+    """ Returns true if the elements are in non-increasing order. """
+    return a >= b
+
+def non_decreasing(a, b):
+    """ Returns true if the elements are in non-decreasing order. """
+    return a <= b
+
+def bubble_sort(input, compare=non_decreasing):
+    """ 
+    The classic bubble sort algorithm.
+
+    Arguments:
+    input -- the list of numbers to be sorted
+
+    Keyword Arguments:
+    compare(a, b) -- function, returns true if the two elements are in order 
+
+    >>> example = [9, 1, 4, 7, 2]
+    >>> bubble_sort(example, non_increasing)
+    [9, 7, 4, 2, 1]
+    >>> bubble_sort(example)
+    [1, 2, 4, 7, 9]
+    """
+    list_len = len(input)
+    for num_sorted in xrange(list_len - 1):
+        # subtract num_sorted from inner loop -- end is already sorted
+        for i in xrange(0, list_len - num_sorted - 1):
+            # test if the element should be swapped with next element
+            if not compare(input[i], input[i+1]):
+                input[i], input[i+1] = input[i+1], input[i] 
+    return input
+
+if __name__ == "__main__":
+    # a check to make sure that docs are up to date
+    import doctest
+    doctest.testmod()

insertion_sort.py

@@ -0,0 +1,28 @@
+"""
+A practice implementation of insertion sort.
+"""
+
+def insertion_sort(array):
+    """ 
+    Basic insertion sort algorithm.
+
+    Arguments:
+    array -- the list of numbers to be sorted
+
+    >>> example = [9, 1, 4, 7, 2]
+    >>> insertion_sort(example)
+    [1, 2, 4, 7, 9]
+    """
+    for i in xrange(1, len(array)):
+        val = array[i]
+        hole = i
+        while hole != 0 and val < array[hole-1]:
+            array[hole] = array[hole-1]
+            hole -= 1
+        array[hole] = val
+    return array
+
+if __name__ == "__main__":
+    # a check to make sure that docs are up to date
+    import doctest
+    doctest.testmod()

merge_sort.py

@@ -0,0 +1,26 @@
+
+
+def merge_sort(array):
+    if len(array) < 2:
+        return array
+    mid = len(array) / 2
+    left = merge_sort(array[:mid])
+    right = merge_sort(array[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    while left and right:
+        if left[0] <= right[0]:
+            result.append(left.pop(0))
+        else: 
+            result.append(right.pop(0))
+    result.extend(right)
+    result.extend(left)
+    return result
+
+if __name__ == '__main__':
+    from random import randint
+    rng = 100000
+    test = [randint(0, rng) for _ in xrange(rng)]
+    assert merge_sort(test) == sorted(test)

quicksort.py

@@ -0,0 +1,20 @@
+
+from random import randint
+
+def quicksort(array):
+    array_length = len(array)
+    if array_length < 2:
+        return array
+    left = []
+    right = []
+    pivot = array.pop(randint(0, array_length-1))
+    while array:
+        val = array.pop()
+        if val > pivot:
+            right.append(val)
+        else:
+            left.append(val)
+    return quicksort(left) + [pivot] + quicksort(right)
+
+if __name__ == '__main__':
+    print quicksort([1,7,3,9,2])

selection_sort.py

@@ -0,0 +1,41 @@
+"""
+A practice implementation of selection sort.
+"""
+
+def gt(a, b):
+    return a > b
+
+def lt(a, b):
+    return a < b
+
+def selection_sort(input, compare=lt):
+    """ 
+    Basic selection sort algorithm.
+
+    Arguments:
+    input -- the list of numbers to be sorted
+
+    Keyword Arguments:
+    compare(a, b) -- function, returns true if the two elements are in order 
+
+    >>> example = [9, 1, 4, 7, 2]
+    >>> selection_sort(example, gt)
+    [9, 7, 4, 2, 1]
+    >>> selection_sort(example)
+    [1, 2, 4, 7, 9]
+    """
+    list_len = len(input)
+    for i in xrange(list_len - 1):
+        # the index where the target, based on compare, resides 
+        target_index = i
+        for j in xrange(i+1, list_len):
+            if not compare(input[target_index], input[j]):
+                target_index = j
+        # swap the target to the end of the sorted list
+        input[i], input[target_index] = input[target_index], input[i]
+    return input
+
+if __name__ == "__main__":
+    # a check to make sure that docs are up to date
+    import doctest
+    doctest.testmod()