Create minHeap.go

[aramzes]

No description provided.

[xfoxawy]

remove debugging

[xfoxawy]

why capacity default to twice size only ?
what if i wanna build a heap size of 1 right now and keep adding new vaues as we go?

[aramzes]

I was thinking of table-doubling based on the need for capacity to make efficient use of the memory

[xfoxawy]

good idea

[xfoxawy]

is this the way to double the size?

[aramzes]

if the capacity is full, a new array is created with double the size of the original array.

[xfoxawy]

try to keep references to old store members , to destroy it once its copied.
to decrease the risk of memory leaks.

[aramzes]

I think golang has automatic garbage collection and once h.store is assigned to the new array, the old one is automatically deleted, am I right?

[xfoxawy]

it has a good gc, it will need some tweaking on compiling.

[aramzes]

package heap

import (
	"fmt"
	"testing"
)

var minHeap *heap

func TestBuildMinHeap(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1, 9}
	minHeap, err := buildMinHeap(values)

	expected := []int{0, 1, 3, 6, 28, 17, 15, 20, 9}
	if err != nil {
		fmt.Println(err)
	} else {
		if minHeap.size == 0 {
			t.Error("Heap was not created successfully")
		} else {
			for i := range expected {
				if minHeap.store[i] != expected[i] {
					t.Error("Expected", expected, "got", minHeap.store)
				}
			}
		}
	}
	fmt.Println(minHeap.store)
}

func TestCheckCapacity(t *testing.T) {
	values := []int{20, 0, 15, 6}
	minHeap, _ := buildMinHeap(values)
	//h := &minHeap

	values2 := []int{28, 17, 3, 1, 9}
	for _, value := range values2 {
		minHeap.insert(value)
	}

	if minHeap.capacity != 16 {
		t.Error("Capacity was not doubled")
	}
}

func TestExtractMin(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1, 9}
	expected := 0
	minHeap, err := buildMinHeap(values)
	if err != nil {
		fmt.Println(err)
	} else {
		if minHeap.size == 0 {
			t.Error("Heap was not created successfully")
		}
	}
	min, err := minHeap.extractMin()
	if err != nil {
		fmt.Println(err)
	} else {
		if min != expected {
			fmt.Println("Expected", expected, "got", min)
		} else {
			fmt.Println("The minimum value is", min)
		}
	}
}

func TestInsert(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1}
	minHeap, _ := buildMinHeap(values)
	minHeap.insert(9)
	expected := []int{0, 1, 3, 6, 28, 17, 15, 20, 9}

	for i := range expected {
		if expected[i] != minHeap.store[i] {
			t.Error("Expected", expected, "got", minHeap.store)
		}
	}
}

func TestHeapifyUp(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1, 9}
	minHeap := heap{store: values, capacity: 16, size: 9}
	minHeap.heapifyUp(7)

	expected := []int{20, 0, 15, 1, 28, 17, 3, 6, 9} // 6 is replaced by 1

	for i := range expected {
		if minHeap.store[i] != expected[i] {
			t.Error("Expected", expected, "got", minHeap.store)
		}
	}
}

func TestParent(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1, 9}
	minHeap, _ := buildMinHeap(values)

	expectedRoot := 0
	expectedLeftChild := 2  //child index 5
	expectedRightChild := 3 //child index 8

	resultRoot, isRoot1 := minHeap.parent(0)
	resultLeftChild, isRoot2 := minHeap.parent(5)
	resultRightChild, isRoot3 := minHeap.parent(8)

	if isRoot1 == false || isRoot2 == true || isRoot3 == true {
		t.Error("isRoot of root is", isRoot1)
		t.Error("isRoot of left child is", isRoot2)
		t.Error("isRoot of right child is", isRoot3)
	} else if resultRoot != expectedRoot || resultLeftChild != expectedLeftChild || resultRightChild != expectedRightChild {
		t.Error("Expected parent of root", expectedRoot, "got", resultRoot)
		t.Error("Expected parent of root", expectedLeftChild, "got", resultLeftChild)
		t.Error("Expected parent of root", expectedRightChild, "got", resultRightChild)
	}
}

func TestHeapifyDown(t *testing.T) {
	values := []int{20, 0, 15, 6, 28, 17, 3, 1, 9}
	minHeap := heap{store: values, capacity: 16, size: 9}
	minHeap.heapifyDown(0)
	expected := []int{0, 6, 15, 1, 28, 17, 3, 20, 9}
	for i := range expected {
		if minHeap.store[i] != expected[i] {
			t.Error("Expected", expected, "got", minHeap.store)
		}
	}
}