Lesson 3, searching and sorting, completed

Author: linkel

3-search-sort/BinarySearch-mine.py

@@ -10,6 +10,8 @@
 Return the index of value, or -1 if the value
 doesn't exist in the list."""
 
+# wow, I really overcomplicated this...
+
 def binary_search(input_array, value):
     """Your code goes here."""
     midpoint = len(input_array)//2 

3-search-sort/BubbleSort-notes.md

@@ -0,0 +1,17 @@
+### Bubble Sort
+
+Bubble Sort has time complexity of O(n^2) for worst case and average case
+because it makes comparisons between two values through the entire array,
+needing to make n-1 comparisons per iteration of bubbling. (n-1)(n-1) = n^2 - 2n + 1
+Best case time complexity is if array is already sorted, which is O(n)
+Space complexity is O(1) because it does not make a new copy of the data structure.
+
+
+### Bubble Sort Quiz Answer:
+
+[21, 4, 1, 3, 9, 20, 25, 6, 21, 14] (Original Array)
+[4, 1, 3, 9, 20, 21, 6, 21, 14, 25] (1)
+[1, 3, 4, 9, 20, 6, 21, 14, 21, 25] (2)
+[1, 3, 4, 9, 6, 20, 14, 21, 21, 25] (3)
+[1, 3, 4, 6, 9, 14, 20, 21, 21, 25] (4)
+

3-search-sort/FibRecursive-mine.py

@@ -0,0 +1,19 @@
+"""Implement a function recursively to get the desired
+Fibonacci sequence value.
+Your code should have the same input/output as the 
+iterative code in the instructions."""
+
+def get_fib(position):
+    if position == 0:
+        return 0
+    elif position == 1:
+        return 1
+    else:
+        return get_fib(position-1) + get_fib(position-2)
+
+# O(2^n) time
+
+# Test cases
+print get_fib(9)
+print get_fib(11)
+print get_fib(0)

3-search-sort/FibRecursive.py

@@ -0,0 +1,4 @@
+def get_fib(position):
+    if position == 0 or position == 1:
+        return position
+    return get_fib(position - 1) + get_fib(position - 2)

3-search-sort/MergeSort-notes.md

@@ -0,0 +1,15 @@
+### Merge Sort
+
+This sorting algorithm breaks everything into arrays of one, and then compares two values to each other and puts them in their own sorted array. Then it compares two arrays, and makes a new sorted array from them, and onwards until completed.
+
+Time complexity is O(n log(n)) because it takes n comparisons for log n number of steps. Space complexity is O(n) since we we are making new arrays as we go through. 
+
+Possible to use in place merge sort to avoid added space complexity. 
+
+
+### Merge Sort Quiz Answer:
+
+[21, 4, 1, 3, 9, 20, 25] (Original Array)
+[21, 1, 4, 3, 9, 20, 25] (1)
+[1, 4, 21, 3, 9, 20, 25] (2)
+[1, 3, 4, 9, 20, 21, 25] (3)

3-search-sort/QuickSort-mine.py

@@ -0,0 +1,33 @@
+"""Implement quick sort in Python.
+Input a list.
+Output a sorted list."""
+def quicksort(array):
+    if len(array) < 2:
+        return array
+    stack_of_index = []
+    index = (0, len(array) - 1)
+    stack_of_index.append(index)
+    for index in stack_of_index:
+        e_index = index[0]
+        pivot_index = index[1]
+        while pivot_index > e_index:
+            pivot = array[pivot_index]
+            e = array[e_index]
+            if e > pivot:
+                array[pivot_index] = e
+                array[e_index] = array[pivot_index - 1]
+                array[pivot_index - 1] = pivot
+                pivot_index -= 1
+            else:
+                e_index += 1
+        low = index[0]
+        high = index[1]
+        if pivot_index > 1 and low < pivot_index - 1:
+            stack_of_index.append((low, pivot_index - 1))
+        if pivot_index < len(array) -1 and pivot_index + 1 < high:
+            stack_of_index.append((pivot_index + 1, high))
+    return array
+            
+
+test = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14]
+print(quicksort(test))

README.md

@@ -1,2 +1,6 @@
 ## Data Structures and Algorithms in Python
-This is a Udacity class that I was marginally curious about as a way to continue supplementing my algorithms/DS practice. 
+This is a Udacity class that I was marginally curious about as a way to continue supplementing my algorithms/DS practice. At this point, MIT 6.00.1x has been very helpful for an introduction to Python, and MIT 6.00.2x gave me a little taste of graphs. 
+
+I am still working through Elements of Programming Interviews, but at times the difficulty level of the problems is quite high and I want something a bit more intermediate. I'm not sure that this class will be exactly what I'm looking for, but I will finish it and consume more material as necessary. MIT's OCW Algorithm's course might also be worth trying out after this. 
+
+Lastly, I plan to also get around to reading Sedgewick's Algorithms once I decide to jump into Java.