Improved the Documentation.

Author: test123

README.md

@@ -2,35 +2,41 @@
 
 Visualizing sorting algorithms, using the matplotlib library.
 
-Algorithms covered so far:<br />
-Quick Sort<br />
-Bubble Sort<br />
-Selection Sort<br />
-Insertion Sort<br />
-Heap Sort<br />
-Merge Sort
+Algorithms covered so far: 
+
+| Name | Function Name |
+| - |:-: |
+| Quick Sort | quick_sort |
+| Bubble Sort | bubble_sort |
+| Selection Sort | selection_sort |
+| Insertion Sort | insertion_sort |
+| Heap Sort | heap_sort |
+| Merge Sort | merge_sort |
 
 # Usage:
 
+Install
+
+```pip install -r requirements.txt``` 
+
 Run
 
 ```python main.py function_name```
 
-Choose function name from list of functions above (in all lower case and spaces replaced by underscore).
+Pass function name as a command line argument from list of functions above
+(in all lower case and spaces replaced by underscore).
 
-For example: 
+**For example:** 
 
 ```python main.py quick_sort```
 
 # How to contribute
 
-Add new sorting algorithms to `sorting.py`  
-In your algorithms, pass an `Array` (defined in `sorting.py`) object, instead of a list.  
-  
-The call to your sorting algorithm should be `sorting_algorithm(Array([1, 2, 3]))`, not `sorting_algorithm([1, 2, 3])`.  
-  
-Whenever you are swapping values, call `Array.swap`, and whenever you are setting a value, call `Array.set`.
-The length of the array can be found out using `Array.length`.
-
-Make sure you test your newly implemented algorithm by running `test.py` after appending it to the list of algorithms in `test.py`.
+**If you want to add a new sorting algorithm:**
 
+1. Code the algorithm in ```sorting.py```.
+2. Name the function appropriately, like ```quick_sort```, ```bubble_sort```.
+3. While coding the function, **do not use python lists**. Instead, use an ```Array``` object. The ```Array``` class is defined in ```sorting.py```. (See already implemented algorithms, for your reference)
+4. The ```Array``` object has ```swap```, ```set```, ```get_len```, ```get``` methods implemented. Feel free to implement any more, additional methods, that you may see fit.
+5. Make sure you add the sorting algorithm to the Readme file!
+6. Make sure your newly implemented algorithm works, by running `test.py` after appending it to the list of algorithms in `test.py`.

sorting.py

@@ -25,7 +25,7 @@ def set(self, index, num):
         if not test:
             vs.plot(self.values)
 
-    def getLen(self):
+    def get_len(self):
         return len(self.values)
 
 
@@ -34,7 +34,7 @@ def bubble_sort(nums):  # n^2
     swapped = True
     while swapped:
         swapped = False
-        for i in range(nums.getLen() - 1):
+        for i in range(nums.get_len() - 1):
             if nums.values[i] > nums.values[i + 1]:
                 # Swap the elements
                 nums.swap(i, i + 1)
@@ -44,11 +44,11 @@ def bubble_sort(nums):  # n^2
 
 def selection_sort(nums):  # n^2
     # This value of i corresponds to how many values were sorted
-    for i in range(nums.getLen()):
+    for i in range(nums.get_len()):
         # We assume that the first item of the unsorted segment is the smallest
         lowest_value_index = i
         # This loop iterates over the unsorted items
-        for j in range(i + 1, nums.getLen()):
+        for j in range(i + 1, nums.get_len()):
             if nums.values[j] < nums.values[lowest_value_index]:
                 lowest_value_index = j
         # Swap values of the lowest unsorted element with the first unsorted
@@ -58,7 +58,7 @@ def selection_sort(nums):  # n^2
 
 def insertion_sort(nums):  # n^2
     # Start on the second element as we assume the first element is sorted
-    for i in range(1, nums.getLen()):
+    for i in range(1, nums.get_len()):
         item_to_insert = nums.values[i]
         # And keep a reference of the index of the previous element
         j = i - 1
@@ -94,7 +94,7 @@ def heapify(nums, heap_size, root_index):
             # Heapify the new root element to ensure it's the largest
             heapify(nums, heap_size, largest)
 
-    n = nums.getLen()
+    n = nums.get_len()
 
     # Create a Max Heap from the list
     # The 2nd argument of range means we stop at the element before -1 i.e.
@@ -147,11 +147,11 @@ def merge(left_list, right_list):
         return sorted_list
 
     # If the list is a single element, return it
-    if nums.getLen() <= 1:
+    if nums.get_len() <= 1:
         return nums.values
 
     # Use floor division to get midpoint, indices must be integers
-    mid = nums.getLen() // 2
+    mid = nums.get_len() // 2
 
     # Sort and merge each half
     left_list = merge_sort(Array(nums.values[:mid]))
@@ -199,4 +199,4 @@ def _quick_sort(items, low, high):
             _quick_sort(items, low, split_index)
             _quick_sort(items, split_index + 1, high)
 
-    _quick_sort(nums, 0, nums.getLen() - 1)
+    _quick_sort(nums, 0, nums.get_len() - 1)