Revamp heap files

Author: 4ndrelim

src/main/java/dataStructures/heap/MaxHeap.java

@@ -6,7 +6,7 @@
 import java.util.Map;
 
 /**
- * Implementation of an array-based max heap structure derived from a binary heap.
+ * Implementation of an (0-indexed) array-based max heap structure derived from a binary heap.
  *
  * Callable methods are:
  * size()               - O(1)
@@ -20,14 +20,6 @@
  * heapify(T ...seq)    - O(n)
  * toString()
  *
- * Notes:
- *        1. Array is essentially filled in level-order
- *        2. 0-indexed implementation
- *        3. Actually it suffices to compare index of left child of a node and size of heap to check if it's a leaf node
- *        4. Heapify deals with bubbling down all elements starting from the back,
- *            what about bubbling-up all elements starting from the front instead?
- *            No issue with correctness, problem lies with efficiency of operation.
- *
  * @param <T> generic type for objects to be stored and queried
  */
 public class MaxHeap<T extends Comparable<T>> {
@@ -255,6 +247,7 @@ private void bubbleUp(int i) {
    * @return boolean value that determines is leaf or not
    */
   private boolean isLeaf(int i) {
+    // actually, suffice to compare index of left child of a node and size of heap
     return this.getRightIndex(i) >= this.size() && this.getLeftIndex(i) >= this.size();
   }
 

src/main/java/dataStructures/heap/MinHeap.java

@@ -1,10 +1,11 @@
 # Heap
 
+## Background
 ### Binary Heap
 A binary heap is often used to introduce the concept of heaps. It is a tree-based data structure that satisfies the 
 following properties:
 1. Complete binary tree - every level, except possibly the last, is completely filled
-2. Max (min) heap property - the value of every vertex in the binary tree is >= (<=) than that of its child vertices
+2. Max (min) heap property - the value of every vertex in the binary tree is >= (<=) than that of its child nodes
 
 This makes it a powerful data structure that provides efficient access to the highest (or lowest) priority element, 
 making it suitable as an underlying implementation of the ADT, priority queue.
@@ -28,16 +29,31 @@ heaps in Python and Java is primarily due to design choices and considerations o
 Further, this operation, without augmentation, would take O(n) due to having to search for the object to begin with
 (see under Notes).
 
-Still, one can circumvent the lack of such operations by simply removing and re-inserting (still O(n)).
+One can circumvent the lack of such operations by simply removing and re-inserting (albeit, still O(n)).
 
-This is worth a mention. In cases like Dijkstra where the concern is having to maintain V nodes in the priority queue 
-by constantly updating rather than insertion of all edges, it is not really a big issue. After all, the log factor 
-in the order of growth will turn log(E) = log(V^2) in the worst case of a complete graph, to 2log(V) = O(log(V)).
+**This is worth a mention:** <br>
+In cases like Dijkstra algorithm, there is no need to strictly maintain V nodes in the priority queue for O(nlogn).
+One can just insert all edges rather than constantly updating (hence, no need for updateKey operations). <br>
+After all, the log factor in the order of growth will turn log(E) = log(V^2) in the worst case of a complete graph, 
+to 2log(V) = O(log(V)).
+
+### Heapify - Choice between bubbleUp and bubbleDown
+Heapify deals with bubbling down (for max heap) all elements starting from the back. <br>
+What about bubbling-up all elements starting from the front instead? <br>
+**No issue with correctness, problem lies with efficiency of operation.**
+
+The number of operations required for bubbleUp and bubbleDown (to maintain heap property), is proportional to the
+distance the node have to move. bubbleDown starts from the bottom level whereas bubbleUp starts from the top level.
+Only 1 node is at the top whereas (approx) half the nodes is at the bottom level. It therefore makes sense to use 
+bubbleDown.
 
 ## Complexity Analysis 
-Time: O(log(n)) in general for most native operations, 
-      except heapify (building a heap from a sequence of elements) that takes o(n) <br>
-Space: O(n) where n is the number of elements (whatever the structure, it must store at least n nodes) <br>
+**Time**: O(log(n)) in general for most native operations, 
+      except heapify (building a heap from a sequence of elements) that takes o(n) 
+
+**Space**: O(n) 
+
+where n is the number of elements (whatever the structure, it must store at least n nodes) 
 
 ## Notes
 1. Heaps are often presented as max-heaps (eg. in textbooks), hence the implementation follows a max-heap structure
@@ -50,3 +66,5 @@ Space: O(n) where n is the number of elements (whatever the structure, it must s
    - The trade-off would be that the heap does not support insertion of duplicate objects else the Map would not work
      as intended.
 3. Rather than using Java arrays, where size must be declared upon initializing, we use list here in the implementation.
+4. [Good read](https://stackoverflow.com/questions/9755721/how-can-building-a-heap-be-on-time-complexity?) on the 
+    time complexity of heapify and making the correct choice between bubbleUp and bubbleDown.