Add heapsort algorithm

Author: sudheerj

Diff for: README.md

@@ -253,12 +253,14 @@ List of Programs related to data structures and algorithms
 
 ## Sorting
 
-   1. Bubble sort: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/bubbleSort/bubbleSort.js)
+   1. Bubble sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/bubbleSort/bubbleSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/bubbleSort/bubbleSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/bubbleSort/bubbleSort.md)
 
-   2. Selection sort: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/selectionSort/selectionSort.js)
+   2. Selection sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/selectionSort/selectionSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/selectionSort/selectionSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/selectionSort/selectionSort.md)
 
-   3. Insertion sort: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/insertionSort/insertionSort.js)
+   3. Insertion sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/insertionSort/insertionSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/insertionSort/insertionSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/insertionSort/insertionSort.md)
 
-   4. Merge sort: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/mergeSort/mergeSort.js)
+   4. Merge sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/mergeSort/mergeSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/mergeSort/mergeSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/mergeSort/mergeSort.md)
 
-   5. Quick sort: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/quickSort/quickSort.js)
+   5. Quick sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/quickSort/quickSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/quickSort/quickSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/quickSort/quickSort.md)
+
+   6. Heap sort: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/heapSort/heapSort.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/heapSort/heapSort.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/sorting/heapSort/heapSort.md)

Diff for: src/java1/sorting/heapSort/HeapSort.java

@@ -0,0 +1,49 @@
+package java1.sorting.heapSort;
+
+import java.util.Arrays;
+
+public class HeapSort {
+
+    private static void heapSort(int[] arr) {
+        int size = arr.length;
+        for(int i = (int)Math.floor(size/2 - 1); i>=0; i--) {
+            heapify(arr, arr.length, i);
+        }
+
+        for (int i = size -1; i > 0 ; i--) {
+            swap(arr, i, 0);
+            heapify(arr, i, 0);
+        }
+    }
+
+    private static void heapify(int[] arr, int size, int parentIndex) {
+        int largest = parentIndex;
+        int leftIndex = 2 * parentIndex + 1;
+        int rightIndex = 2 * parentIndex + 2;
+
+        if(leftIndex < size && arr[leftIndex] > arr[largest]) {
+            largest = leftIndex;
+        }
+
+        if(rightIndex < size && arr[rightIndex] > arr[largest]) {
+            largest = rightIndex;
+        }
+
+        if(parentIndex != largest) {
+            swap(arr, parentIndex, largest);
+            heapify(arr, size, largest);
+        }
+    }
+
+    private static void swap(int[] arr, int first, int second) {
+        int temp = arr[first];
+        arr[first] = arr[second];
+        arr[second] = temp;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = { 40, 50, 20, 0, -10, 30, 10 };
+        heapSort(arr);
+        System.out.println(Arrays.toString(arr));
+    }
+}

Diff for: src/java1/sorting/heapSort/heapSort.md

@@ -0,0 +1,13 @@
+# Heap Sort
+HeapSort is an in-place comparison based sorting algorithm that uses **binary heap** data structure. The main idea behind this heap sort is to find either the highest value(max heap) or lowest value(min heap) and place it at the end, repeating the process until all the values are sorted.
+
+## How it works
+1. Build a max heap based on given input array.
+2. Switch the top root with the last node and then remove it from the heap.
+3. Rebuild the max heap again and repeat until there is only one element remaining in the heap.
+
+## Complexity
+
+| Best            | Average             | Worst               | Space (Memory)    | Stable    | Advantage  |
+| :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+|  Ω(n log(n))               | θ(n log(n))       | O(n log(n))       | O(1)         | Yes       |   Sort efficiently large data sets        |

Diff for: src/java1/sorting/quickSort/README.md

@@ -12,4 +12,4 @@ QuickSort is a sorting algorithm based on **Divide and Conquer technique** that
 
 | Best            | Average             | Worst               | Space (Memory)    | Stable    | Advantage  |
 | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
-|  Ω(n log(n))               | θ(n log(n))       | O(n<sup>2</sup>)       | O(1)         | Yes       |   Efficient alogorithm except for almost sorted arrays        |
+|  Ω(n log(n))               | θ(n log(n))       | O(n<sup>2</sup>)       | O(log n)         | Yes       |   Efficient alogorithm except for almost sorted arrays        |

Diff for: src/javascript/sorting/heapSort/heapSort.js

@@ -0,0 +1,35 @@
+function heapSort(arr) {
+    let size = arr.length;
+
+    for (let i = Math.floor(size/2 - 1); i >= 0; i--) {
+        heapify(arr, size, i);        
+    }
+
+    for (let i = size - 1; i >= 0; i--) {
+        [arr[i], arr[0]] = [arr[0], arr[i]];
+        heapify(arr, i, 0);
+    }
+}
+
+function heapify(arr, size, parentIndex) {
+    let largest = parentIndex;
+    let leftChild = 2 * parentIndex + 1;
+    let rightChild = 2 * parentIndex + 2;
+
+    if(leftChild < size && arr[leftChild] > arr[largest]) {
+        largest = leftChild;
+    }
+
+    if(rightChild < size && arr[rightChild] > arr[largest]) {
+        largest = rightChild;
+    }
+
+    if(parentIndex !== largest) {
+        [arr[parentIndex], arr[largest]] = [arr[largest], arr[parentIndex]];
+        heapify(arr, size, largest);
+    }
+}
+
+let arr = [40, 50, 20, 0, -10, 30, 10];
+heapSort(arr);
+console.log(arr);

Diff for: src/javascript/sorting/heapSort/heapSort.md

@@ -0,0 +1,13 @@
+# Heap Sort
+HeapSort is an in-place comparison based sorting algorithm that uses **binary heap** data structure. The main idea behind this heap sort is to find either the highest value(max heap) or lowest value(min heap) and place it at the end, repeating the process until all the values are sorted.
+
+## How it works
+1. Build a max heap based on given input array.
+2. Switch the top root with the last node and then remove it from the heap.
+3. Rebuild the max heap again and repeat until there is only one element remaining in the heap.
+
+## Complexity
+
+| Best            | Average             | Worst               | Space (Memory)    | Stable    | Advantage  |
+| :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+|  Ω(n log(n))               | θ(n log(n))       | O(n log(n))       | O(1)         | Yes       |   Sort efficiently large data sets        |

Diff for: src/javascript/sorting/quickSort/quickSort.md

@@ -12,4 +12,4 @@ QuickSort is a sorting algorithm based on **Divide and Conquer technique** that
 
 | Best            | Average             | Worst               | Space (Memory)    | Stable    | Advantage  |
 | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
-|  Ω(n log(n))               | θ(n log(n))       | O(n<sup>2</sup>)       | O(1)         | Yes       |   Efficient alogorithm except for almost sorted arrays        |
+|  Ω(n log(n))               | θ(n log(n))       | O(n<sup>2</sup>)       | O(log n)           | Yes       |   Efficient alogorithm except for almost sorted arrays        |