add heap sort

Author: danrusei

README.md

@@ -59,7 +59,7 @@ WIP, the description of the below `unsolved yet` problems can be found in the or
 - [x] [Bubble Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/bubble_sort)
 - [x] [Insertion Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/insertion_sort)
 - [x] [Merge Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/merge_sort)
-- [] Heap Sort (Binary Heap)
+- [x] [Heap Sort (Binary Heap)](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/heap_sort)
 - [x] [Quick Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/quick_sort)
 - [] Interpolation Search
 - [] Find Kth Smallest/Largest Element In Unsorted Array

sorting/bubble_sort/README.md

@@ -6,9 +6,9 @@ Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorith
 
 ## Complexity
 
-Worst Case Time Complexity [ Big-O ]: **O(n2)**  
+Worst Case Time Complexity [ Big-O ]: **O(n * n)**  
 Best Case Time Complexity [Big-omega]: **O(n)**- when the list is already sorted  
-Average Time Complexity [Big-theta]: **O(n2)**  
+Average Time Complexity [Big-theta]: **O(n * n)**  
 Space Complexity: **O(1)**- because only a single additional memory space is required for temp variable  
 
 ## Example

sorting/heap_sort/README.md

@@ -0,0 +1,18 @@
+# Heap Sort
+
+Heap sort is a comparison based sorting technique based on Binary Heap data structure. It is similar to selection sort where we first find the maximum element and place the maximum element at the end. We repeat the same process for the remaining elements.
+
+Source: [Geeksforgeeks](https://www.geeksforgeeks.org/heap-sort/)
+
+## Complexity
+
+Worst Case Time Complexity [ Big-O ]: **O(n log n)**  
+Best Case Time Complexity [Big-omega]: **O(n log n)**  
+Average Time Complexity [Big-theta]: **O(n log n)**  
+Space Complexity: **O(n)**
+
+## Algorithm
+
+* Build a max heap from the input data.
+* At this point, the largest item is stored at the root of the heap. Replace it with the last item of the heap followed by reducing the size of heap by 1. Finally, heapify the root of the tree.
+* Repeat step 2 while size of heap is greater than 1.

sorting/heap_sort/heap.go

@@ -0,0 +1,46 @@
+package heapsort
+
+func heapsort(target []int) {
+	n := len(target)
+	sortIt(target, n)
+}
+
+func sortIt(target []int, n int) {
+
+	// Build heap (rearrange slice)
+	for i := n/2 - 1; i >= 0; i-- {
+		heapify(target, n, i)
+	}
+
+	// One by one extract an element from heap
+	for i := n - 1; i > 0; i-- {
+		// move current root to end
+		target[0], target[i] = target[i], target[0]
+		// call max heapify on the reduced heap
+		heapify(target, i, 0)
+	}
+}
+
+func heapify(target []int, n int, i int) {
+
+	// If the parent node is stored at index i,
+	// the left child can be calculated by 2 * i + 1 and
+	// right child by 2 * i + 2
+	largest := i
+	left := 2*i + 1
+	right := 2*i + 2
+
+	if left < n && target[left] > target[largest] {
+		largest = left
+	}
+
+	if right < n && target[right] > target[largest] {
+		largest = right
+	}
+
+	if largest != i {
+		target[i], target[largest] = target[largest], target[i]
+		// recursively heapify the affected sub-tree
+		heapify(target, n, largest)
+	}
+}

sorting/heap_sort/heap_test.go

@@ -0,0 +1,17 @@
+package heapsort
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestMergeSort(t *testing.T) {
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			heapsort(tc.original)
+			if !reflect.DeepEqual(tc.original, tc.sorted) {
+				t.Errorf("got: %v, want: %v", tc.original, tc.sorted)
+			}
+		})
+	}
+}

sorting/heap_sort/test_cases.go

@@ -0,0 +1,28 @@
+package heapsort
+
+var testcases = []struct {
+	name     string
+	original []int
+	sorted   []int
+}{
+	{
+		name:     "4 elements in list",
+		original: []int{4, 2, 3, 1},
+		sorted:   []int{1, 2, 3, 4},
+	},
+	{
+		name:     "empty list",
+		original: []int{},
+		sorted:   []int{},
+	},
+	{
+		name:     "already sorted list",
+		original: []int{10, 20, 30, 40},
+		sorted:   []int{10, 20, 30, 40},
+	},
+	{
+		name:     "9 elements in the list",
+		original: []int{11, 21, 12, 4, 3, 100, 1000, 1, 123},
+		sorted:   []int{1, 3, 4, 11, 12, 21, 100, 123, 1000},
+	},
+}

sorting/insertion_sort/README.md

@@ -6,9 +6,9 @@ Insertion sort is a simple sorting algorithm that builds the final sorted array
 
 ## Complexity
 
-Worst Case Time Complexity [ Big-O ]: **O(n2)**  
+Worst Case Time Complexity [ Big-O ]: **O(n * n)**  
 Best Case Time Complexity [Big-omega]: **O(n)**  
-Average Time Complexity [Big-theta]: **O(n2)**  
+Average Time Complexity [Big-theta]: **O(n * n)**  
 Space Complexity: **O(n)**
 
 ## Algorithm

sorting/quick_sort/README.md

@@ -6,7 +6,7 @@ Quicksort is a divide-and-conquer algorithm. It works by selecting a 'pivot' ele
 
 ## Complexity
 
-Worst Case Time Complexity [ Big-O ]: **O(n2)**  
+Worst Case Time Complexity [ Big-O ]: **O(n * n)**  
 Best Case Time Complexity [Big-omega]: **O(n log n)**  
 Average Time Complexity [Big-theta]: **O(n log n)**  
 Space Complexity: **O(n)**