Update HSExp.md

Author: LindaStern

src/algorithms/explanations/HSExp.md

@@ -2,22 +2,34 @@
 
 ---
 
-Heap Sort is a popular and efficient sorting algorithm in computer programming. Learning how to write the heap sort algorithm requires knowledge of two types of data structures - arrays and trees.
+Heapsort is a general purpose sorting algorithm that has *<verbatim>O(n log n)</verbatim>* behavior on every input. It achieves this by processing the data using a priority queue known as a heap.  
 
-The initial set of numbers that we want to sort is stored in an array e.g. `[10, 3, 76, 34, 23, 32]` and after sorting, we get a sorted array `[3,10,23,32,34,76]`.
+### Heap Data Structure
 
-Heap sort works by visualizing the elements of the array as a special kind of complete binary tree called a heap.
+The heap data structure is a priority queue that avoids the worst case behavior of lists and arrays, where unsorted lists or arrays are
+*<verbatim>O(n)</verbatim>* for finding and removing the maximum (or minimum for a min-priority queue) item and sorted lists or arrays are *<verbatim>O(n)</verbatim>* for inserting a new item into the priority queue.  By contrast, heaps exhibit *<verbatim>O(log n)</verbatim>* behavior for both insertion and removal from the priority queue.
 
-## Heap Data Structure
+The items in a heap are stored in an array.  For ease of conceptualization, the array can be considered as a binary tree, where array element *<verbatim>A[i]</verbatim>* is a parent node with two children that are array elements *<verbatim>A[2i]</verbatim>* and *<verbatim>A[2i+1]</verbatim>*.     
 
-Heap is a special tree-based data structure. A binary tree is said to follow a heap data structure if
+Since there are no gaps in data in the array, the heap tree is complete. 
+In a *max*-heap each node is larger or equal to both of its children. This property means that the root node, or the element *A[i]* is the largest item.   
 
-* It is a complete binary tree.
-* All nodes in the tree follow the property that they are greater than their children i.e. the largest element is at the root and both its children and smaller than the root and so on. Such a heap is called a max-heap. If instead, all nodes are smaller than their children, it is called a min-heap
+PUT IN HERE SOMETHING ABOUT FORMING THE HEAP, I think.
 
-## Sorting with the heap
+### Sorting with the heap
 
-Once the heap has been formed, sorting is straightforward.  For a max-heap repeatedly swap the root (largest item) with the last item in the array, and reform the heap.   
+Once the heap has been formed, sorting is straightforward.  Using a *max*-heap, repeatedly swap the root (largest item) with the last available item in the array and make this array element no longer available for swapping.  At this point, the root no longer contains the largest element, so the heap order must be restored.    
+
+The heap is restored by checking every "parent node" in the array, to make sure it is larger than either of its "children". Parent nodes are at positions 1 - *n/2* in the array, because the last *n/2* nodes are leaves, *i.e.* have no children.  The parent node is checked to make sure it is larger than either of its two children.  If it is, then no action is necessary. If it isn't, then is it swapped with the largest of its two children. Initially we will be making a mini-heap of three items.  Then 
+
+
+CONTINUE HERE 
+
+
+
+
+
+MAYBE PUT SOMETHING in the More information tab about the analysis and why this is O(n).
 
 ## Complexity