add merge sort

Author: danrusei

README.md

@@ -56,7 +56,7 @@ The intent of this repository is to solve in **Go** the problems identified in t
 - [] Search an element in a sorted and rotated array
 - [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)
-- [] Merge Sort
+- [x] [Merge Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/merge_sort)
 - [] Heap Sort (Binary Heap)
 - [x] [Quick Sort](https://github.com/danrusei/algorithms_with_Go/tree/main/sorting/quick_sort)
 - [] Interpolation Search

sorting/merge_sort/README.md

@@ -0,0 +1,19 @@
+# Merge Sort
+
+Source: [Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
+
+Like QuickSort, Merge Sort is a Divide and Conquer algorithm. It divides the input array into two halves, calls itself for the two halves, and then merges the two sorted halves.
+
+## 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
+
+* Divide the unsorted list into n sublists, each containing one element (a list of one element is considered sorted).
+* Repeatedly merge sublists to produce new sorted sublists until there is only one sublist remaining. This will be the sorted list.
+
+![merge sort algorithm](merge_sort_algorithm.png)

sorting/merge_sort/merge.go

@@ -0,0 +1,68 @@
+package mergesort
+
+func mergesort(target []int) {
+	left := 0
+	right := len(target) - 1
+	sortIt(target, left, right)
+}
+
+// run recursively with a modified left and right index of the slice
+func sortIt(target []int, left int, right int) {
+	if left >= right {
+		return
+	}
+	mid := (left + right - 1) / 2
+
+	sortIt(target, left, mid)
+	sortIt(target, mid+1, right)
+
+	merge(target, left, mid, right)
+}
+
+func merge(target []int, left int, mid int, right int) {
+
+	//find the sizes of the two slices
+	n1 := mid - left + 1
+	n2 := right - mid
+
+	//create temp slices
+	leftSlice := make([]int, n1)
+	rightSlice := make([]int, n2)
+
+	//copy data to the temp slices
+	for i := 0; i < n1; i++ {
+		leftSlice[i] = target[left+i]
+	}
+	for j := 0; j < n2; j++ {
+		rightSlice[j] = target[mid+1+j]
+	}
+
+	//merge the temp slices
+	var i, j = 0, 0
+	k := left
+
+	for i < n1 && j < n2 {
+		if leftSlice[i] <= rightSlice[j] {
+			target[k] = leftSlice[i]
+			i++
+		} else {
+			target[k] = rightSlice[j]
+			j++
+		}
+		k++
+	}
+
+	//copy the remaining elements from leftSlice
+	for i < n1 {
+		target[k] = leftSlice[i]
+		i++
+		k++
+	}
+
+	//copy the remaining elements from leftSlice
+	for j < n2 {
+		target[k] = rightSlice[j]
+		j++
+		k++
+	}
+}

sorting/merge_sort/merge_sort_algorithm.png

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

sorting/merge_sort/merge_test.go

@@ -0,0 +1,28 @@
+package mergesort
+
+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/merge_sort/test_cases.go

@@ -7,7 +7,7 @@ Quicksort is a divide-and-conquer algorithm. It works by selecting a 'pivot' ele
 ## Complexity
 
 Worst Case Time Complexity [ Big-O ]: **O(n2)**  
-Best Case Time Complexity [Big-omega]: **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)**