Convert to python

Author: seanchen1991

.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
-node_modules
+node_modules
+*.pyc

README.md

@@ -1,24 +1,25 @@
 # Sprint Challenge: Data Structures and Algorithms
 
-For this sprint challenge, you'll be implementing a few functions that build off of some of the data structures you implemented in the first half of the week. Then you'll be analyzing the runtimes of all of the data structure methods. 
+For the data structures portion of this sprint challenge, you'll be implementing a few functions that build off of some of the data structures you implemented in the first half of the week. Then you'll be analyzing the runtimes of these functions.
 
 For the algorithms portion of the sprint challenge, you'll be answering the questions posed in the `exercises.pdf` file regarding runtime complexities and algorithmic paradigms.
 
 ## Data Structures
-Before getting started, run `npm install` in the root-level directory to install needed dependencies for testing.
 
 ### Task 1. Implement Depth-First and Breadth-First Traversal on the Binary Search Tree Class 
-Navigate into the `data_structures` directory. Inside the `src` directory, you'll see the `binary-search-tree.js` file with the completed code for the binary search tree class. Your first task is to implement the methods `depthFirstForEach` and `breadthFirstForEach` on the `BinarySearchTree` class. Think about what data structures you'll need to use in order to achieve the desired order of each respective method:
+Navigate into the `ex_1` directory in the `data_structures` directory. Inside, you'll see the `binary-search-tree.py` file with a complete implementation of the binary search tree class. Your first task is to implement the methods `depth_first_for_each` and `breadth_first_for_each` on the `BinarySearchTree` class:
 
-   * `depthFirstForEach(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [depth-first](https://en.wikipedia.org/wiki/Depth-first_search) order, applying the supplied callback function to each tree element in turn. 
-   * `breadthFirstForEach(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [breadth-first](https://en.wikipedia.org/wiki/Breadth-first_search) order, applying the supplied callback function to each tree element in turn.
+   * `depth_first_for_each(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [depth-first](https://en.wikipedia.org/wiki/Depth-first_search) order, applying the supplied callback function to each tree element in turn. 
+   * `breadth_first_for_each(cb)` receives a callback function as a parameter. This method iterates over the binary search tree in [breadth-first](https://en.wikipedia.org/wiki/Breadth-first_search) order, applying the supplied callback function to each tree element in turn.
 
-Run `npm test binary-search-tree` to run the tests for this function to ensure that your implementation is correct.
+NOTE: In Python, anonymous functions are referred to as "lambda functions". When passing in a callback function as input to either `depth_first_for_each` or `breadth_first_for_each`, you'll want to define the callbacks as lambda functions. For more information on lambda functions, check out this documentation: [https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions](https://docs.python.org/3/tutorial/controlflow.html#lambda-expressions)
+
+Run `python3 test_binary_search_tree.py` to run the tests for these methods to ensure that your implementation is correct.
 
 ### Task 2. Implement Heapsort
-Inside the `src` directory you'll also find the `heap.js` file with the completed code for the Heap class that you worked on. Your second task is to implement a sorting method called [heapsort](https://en.wikipedia.org/wiki/Heapsort) that uses the heap data structure in order to sort an array of numbers. Your `heapsort` function should return a new array containing all of the sorted data.
+Inside the `ex_2` directory you'll find the `heap.py` file with a working implementation of the heap class. Your second task is to implement a sorting method called [heapsort](https://en.wikipedia.org/wiki/Heapsort) that uses the heap data structure in order to sort an array of numbers. Your `heapsort` function should return a new array containing all of the sorted data.
 
-Run `npm test heap` to run the tests for your `heapsort` function to ensure that your implementation is correct.
+Run `python3 test_heap.py` to run the tests for your `heapsort` function to ensure that your implementation is correct.
 
 ### Task 3. Analyze some runtimes
 Open up the `Data_Structures_Answers.md` file. This is where you'll jot down your answers for the runtimes of the functions you just implemented. Be sure to also answer any other questions posed in the `Answers.md` file!

data_structures/Data_Structures_Question.md

@@ -0,0 +1,13 @@
+Add your answers to the questions below.
+
+1. What is the runtime complexity of your `depth_first_for_each` method?
+
+2. What is the space complexity of your `depth_first_for_each` function?
+
+3. What is the runtime complexity of your `breadth_first_for_each` method?
+
+4. What is the space complexity of your `breadth_first_for_each` method?
+
+5. What is the runtime complexity of your `heapsort` function?
+
+6. What is the space complexity of the `heapsort` function? Recall that your implementation should return a new array with the sorted data. What would be the space complexity if your function instead altered the input array?

data_structures/Data_Structures_Questions.md

@@ -0,0 +1,46 @@
+class BinarySearchTree:
+  def __init__(self, value):
+    self.value = value
+    self.left = None
+    self.right = None
+
+  def depth_first_for_each(self, cb):
+    pass    
+
+  def breadth_first_for_each(self, cb):
+    pass
+
+  def insert(self, value):
+    new_tree = BinarySearchTree(value)
+    if (value < self.value):
+      if not self.left:
+        self.left = new_tree
+      else:
+        self.left.insert(value)
+    elif value >= self.value:
+      if not self.right:
+        self.right = new_tree
+      else:
+        self.right.insert(value)
+
+  def contains(self, target):
+    if self.value == target:
+      return True
+    if self.left:
+      if self.left.contains(target):
+        return True
+    if self.right:
+      if self.right.contains(target):
+        return True
+    return False
+
+  def get_max(self):
+    if not self:
+      return None
+    max_value = self.value
+    current = self
+    while current:
+      if current.value > max_value:
+        max_value = current.value
+      current = current.right
+    return max_value

data_structures/ex_1/binary_search_tree.py

@@ -0,0 +1,34 @@
+import unittest
+from binary_search_tree import BinarySearchTree
+
+class BinarySearchTreeTests(unittest.TestCase):
+  def setUp(self):
+    self.bst = BinarySearchTree(5)
+
+  def test_depth_first_for_each_executes_callback(self):
+    arr = []
+    cb = lambda x: arr.append(x)
+
+    self.bst.insert(2)
+    self.bst.insert(3)
+    self.bst.insert(7)
+    self.bst.insert(9)
+    self.bst.depth_first_for_each(cb)
+
+    self.assertEqual(arr, [5, 2, 3, 7, 9])
+
+  def test_breadth_first_for_each_executes_callback(self):
+    arr = []
+    cb = lambda x: arr.append(x)
+
+    self.bst.insert(3)
+    self.bst.insert(4)
+    self.bst.insert(10)
+    self.bst.insert(9)
+    self.bst.insert(11)
+    self.bst.breadth_first_for_each(cb)
+
+    self.assertEqual(arr, [5, 3, 10, 4, 9, 11])
+
+if __name__ == '__main__':
+  unittest.main()

data_structures/ex_1/test_binary_search_tree.py

@@ -0,0 +1,60 @@
+from math import floor
+
+def heapsort(arr):
+  pass
+
+class Heap:
+  def __init__(self):
+    self.storage = []
+
+  def insert(self, value):
+    self.storage.append(value)
+    self._bubble_up(len(self.storage) - 1)
+
+  def delete(self):
+    if not len(self.storage):
+      return None
+    if len(self.storage) == 1:
+      return self.storage.pop()
+    max_value = self.storage[0]
+    self.storage[0] = self.storage.pop()
+    self._sift_down(0)
+    return max_value
+
+  def get_max(self):
+    return self.storage[0]
+
+  def get_size(self):
+    return len(self.storage)
+
+  def _bubble_up(self, index):
+    parent_index = floor((index - 1) / 2) if index > 0 else 0
+    if self.storage[parent_index] < self.storage[index]:
+      self.storage[parent_index], self.storage[index] = self.storage[index], self.storage[parent_index]
+      self._bubble_up(parent_index)
+
+  def _sift_down(self, index):
+    left_index = index * 2 + 1
+    right_index = index * 2 + 2
+    max_child_index = len(self.storage) - 1 
+    
+    try:
+      left_child = self.storage[left_index]
+    except IndexError:
+      left_child = None
+
+    try:
+      right_child = self.storage[right_index]
+    except IndexError:
+      right_child = None
+
+    if left_child and right_child:
+      max_child_index = left_index if left_child > right_child else right_index
+    elif left_child:
+      max_child_index = left_index
+    elif right_child:
+      max_child_index = right_child
+
+    if self.storage[index] < self.storage[max_child_index]:
+      self.storage[max_child_index], self.storage[index] = self.storage[index], self.storage[max_child_index]
+      self._sift_down(max_child_index)

data_structures/ex_2/heap.py

@@ -0,0 +1,27 @@
+import unittest
+from random import randint
+from heap import heapsort
+
+def gen_random_input(length, max):
+  input = []
+  for i in range(length):
+    input.append(randint(0, max))
+  return input
+
+def is_sorted(arr):
+  for i in range(len(arr) - 1):
+    if arr[i] > arr[i+1]:
+      return False
+  return True
+
+class HeapTests(unittest.TestCase):
+  def test_heap_sort_correctness(self):
+    length = randint(100, 1000)
+    input = gen_random_input(length, 1000)
+    output = heapsort(input)
+
+    self.assertEqual(len(output), length)
+    self.assertTrue(is_sorted(output))
+
+if __name__ == '__main__':
+  unittest.main()