feat: Add heap sample. (#4)

Author: goloroden

README.md

@@ -6,10 +6,11 @@ codingcircle contains the examples from the YouTube Coding Cirle.
 
 So far, the following exercises have been covered:
 
-- [Autocomplete](./autocomplete/) – implement an autocomplete feature using a trie
-- [Continous maximum](./continuousmax/) – calculate the maximum of a sliding window
-- [Remove k-th last element](./removekthlastelement/) – remove the k-th last element from a single-linked list
-- [Running median](./runningmedian/) – calculate the running median of a sequence of numbers
+- [Autocomplete](./autocomplete/) – implements an autocomplete feature using a trie
+- [Continous maximum](./continuousmax/) – calculates the maximum of a sliding window
+- [Heap](./heap/) – implements a heap from scratch, without using the built-in `container/heap` package
+- [Remove k-th last element](./removekthlastelement/) – removes the k-th last element from a single-linked list
+- [Running median](./runningmedian/) – calculates the running median of a sequence of numbers
 
 ## Running quality assurance
 

heap/documentation.go

@@ -0,0 +1,3 @@
+// Package heap implements a min heap data structure without
+// using the built-in container/heap package.
+package heap

heap/min_heap.go

@@ -0,0 +1,116 @@
+package heap
+
+import "errors"
+
+type Item[TValue any] struct {
+	Value    TValue
+	Priority int
+}
+
+type MinHeap[TValue any] struct {
+	items []Item[TValue]
+}
+
+func New[TValue any]() *MinHeap[TValue] {
+	return &MinHeap[TValue]{}
+}
+
+func parentIndex(i int) int {
+	return (i - 1) / 2
+}
+
+func leftChildIndex(i int) int {
+	return 2*i + 1
+}
+
+func rightChildIndex(i int) int {
+	return 2*i + 2
+}
+
+func (h *MinHeap[TValue]) siftUp(index int) {
+	for index > 0 {
+		parent := parentIndex(index)
+
+		if h.items[parent].Priority > h.items[index].Priority {
+			h.items[parent], h.items[index] = h.items[index], h.items[parent]
+			index = parent
+		} else {
+			break
+		}
+	}
+}
+
+func (h *MinHeap[TValue]) siftDown(index int) {
+	left := leftChildIndex(index)
+	right := rightChildIndex(index)
+	smallest := index
+
+	if left < len(h.items) && h.items[left].Priority < h.items[smallest].Priority {
+		smallest = left
+	}
+
+	if right < len(h.items) && h.items[right].Priority < h.items[smallest].Priority {
+		smallest = right
+	}
+
+	if smallest != index {
+		h.items[index], h.items[smallest] = h.items[smallest], h.items[index]
+		h.siftDown(smallest)
+	}
+}
+
+func (h *MinHeap[TValue]) Peek() *Item[TValue] {
+	if len(h.items) == 0 {
+		return nil
+	}
+
+	return &h.items[0]
+}
+
+func (h *MinHeap[TValue]) IsValid() bool {
+	for i := 1; i < len(h.items); i++ {
+		if h.items[parentIndex(i)].Priority > h.items[i].Priority {
+			return false
+		}
+	}
+	return true
+}
+
+func (h *MinHeap[TValue]) Insert(value TValue, priority int) {
+	h.items = append(h.items, Item[TValue]{Priority: priority, Value: value})
+	h.siftUp(len(h.items) - 1)
+}
+
+func (h *MinHeap[TValue]) Remove(index int) error {
+	if index < 0 || index >= len(h.items) {
+		return errors.New("index out of range")
+	}
+
+	h.items[index] = h.items[len(h.items)-1]
+	h.items = h.items[:len(h.items)-1]
+
+	h.siftDown(index)
+
+	return nil
+}
+
+func (h *MinHeap[TValue]) Update(index int, newPriority int) error {
+	if index < 0 || index >= len(h.items) {
+		return errors.New("index out of range")
+	}
+
+	oldPriority := h.items[index].Priority
+	h.items[index].Priority = newPriority
+
+	if newPriority < oldPriority {
+		h.siftUp(index)
+	} else {
+		h.siftDown(index)
+	}
+
+	return nil
+}
+
+func (h *MinHeap[TValue]) Items() []Item[TValue] {
+	return h.items
+}

heap/min_heap_test.go

@@ -0,0 +1,170 @@
+package heap_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/thenativeweb/codingcircle/heap"
+)
+
+func TestNew(t *testing.T) {
+	t.Run("Creates an empty heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 0)
+	})
+}
+
+func TestInsert(t *testing.T) {
+	t.Run("Inserts a value into the heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(23, 1)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 1)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 23, Priority: 1},
+		}, h.Items())
+	})
+
+	t.Run("Inserts multiple values into the heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(42, 2)
+		h.Insert(17, 3)
+		h.Insert(23, 1)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 3)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 23, Priority: 1},
+			{Value: 17, Priority: 3},
+			{Value: 42, Priority: 2},
+		}, h.Items())
+	})
+}
+
+func TestRemove(t *testing.T) {
+	t.Run("Removes a value from the heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(23, 1)
+
+		err := h.Remove(0)
+		assert.NoError(t, err)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 0)
+	})
+
+	t.Run("Removes multiple values from the heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(42, 2)
+		h.Insert(17, 3)
+		h.Insert(23, 1)
+
+		err := h.Remove(1)
+		assert.NoError(t, err)
+		err = h.Remove(1)
+		assert.NoError(t, err)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 1)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 23, Priority: 1},
+		}, h.Items())
+	})
+}
+
+func TestUpdate(t *testing.T) {
+	t.Run("Updates a value in the heap.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(42, 2)
+		h.Insert(17, 3)
+		h.Insert(23, 1)
+
+		err := h.Update(2, 0)
+		assert.NoError(t, err)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 3)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 42, Priority: 0},
+			{Value: 17, Priority: 3},
+			{Value: 23, Priority: 1},
+		}, h.Items())
+	})
+}
+
+func TestPeek(t *testing.T) {
+	t.Run("Returns the minimum value.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(42, 2)
+		h.Insert(17, 3)
+		h.Insert(23, 1)
+
+		assert.Equal(t, 23, h.Peek().Value)
+		assert.Equal(t, 1, h.Peek().Priority)
+	})
+
+	t.Run("Returns nil if the heap is empty.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		assert.Nil(t, h.Peek())
+	})
+}
+
+func TestComplex(t *testing.T) {
+	t.Run("Complex test.", func(t *testing.T) {
+		h := heap.New[int]()
+
+		h.Insert(27, 6)
+		h.Insert(9, 3)
+		h.Insert(17, 5)
+		h.Insert(2, 1)
+		h.Insert(12, 4)
+		h.Insert(8, 2)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 6)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 2, Priority: 1},
+			{Value: 9, Priority: 3},
+			{Value: 8, Priority: 2},
+			{Value: 27, Priority: 6},
+			{Value: 12, Priority: 4},
+			{Value: 17, Priority: 5},
+		}, h.Items())
+
+		err := h.Remove(3)
+		assert.NoError(t, err)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 5)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 2, Priority: 1},
+			{Value: 9, Priority: 3},
+			{Value: 8, Priority: 2},
+			{Value: 17, Priority: 5},
+			{Value: 12, Priority: 4},
+		}, h.Items())
+
+		err = h.Update(3, -1)
+		assert.NoError(t, err)
+
+		assert.True(t, h.IsValid())
+		assert.Len(t, h.Items(), 5)
+		assert.Equal(t, []heap.Item[int]{
+			{Value: 17, Priority: -1},
+			{Value: 2, Priority: 1},
+			{Value: 8, Priority: 2},
+			{Value: 9, Priority: 3},
+			{Value: 12, Priority: 4},
+		}, h.Items())
+	})
+}