Added binary search tree

bst.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+)
+
+type BinarySearchTree struct {
+	rootNode      *BSTNode
+	LastHopsCheck int
+}
+
+type BSTNode struct {
+	Left  *BSTNode
+	Right *BSTNode
+	Key   uint64
+}
+
+func (n *BSTNode) Print(prefix string, isTail bool) {
+	if n.Right != nil {
+		newPrefix := prefix
+		if isTail {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		n.Right.Print(newPrefix, false)
+	}
+
+	fmt.Println(prefix + (func() string {
+		if isTail {
+			return "└── "
+		}
+		return "┌── "
+	}()) + strconv.FormatUint(n.Key, 10))
+
+	if n.Left != nil {
+		newPrefix := prefix
+		if isTail {
+			newPrefix += "    "
+		} else {
+			newPrefix += "│   "
+		}
+		n.Left.Print(newPrefix, true)
+	}
+}
+
+func (n *BSTNode) Insert(key uint64) error {
+	if key > n.Key {
+		// right has not been set
+		if n.Right == nil {
+			n.Right = &BSTNode{
+				Key: key,
+			}
+
+			return nil
+		}
+
+		n.Right.Insert(key)
+	}
+
+	if key < n.Key {
+		// left has not been set
+		if n.Left == nil {
+			n.Left = &BSTNode{
+				Key: key,
+			}
+
+			return nil
+		}
+
+		n.Left.Insert(key)
+	}
+
+	return errors.New("duplicate key passed")
+}
+
+func (t *BinarySearchTree) Exists(key uint64) bool {
+	exists, hops := t.rootNode.Exists(key, 0)
+
+	t.LastHopsCheck = hops
+
+	return exists
+}
+
+func (n *BSTNode) Exists(key uint64, hop int) (bool, int) {
+	if n.Key == key {
+		return true, hop
+	}
+
+	if key < n.Key && n.Left != nil {
+		return n.Left.Exists(key, hop+1)
+	}
+
+	if key > n.Key && n.Right != nil {
+		return n.Right.Exists(key, hop+1)
+	}
+
+	return false, hop
+}
+
+func (t *BinarySearchTree) Insert(key uint64) {
+	if t.rootNode == nil {
+		t.rootNode = &BSTNode{
+			Key: key,
+		}
+	}
+
+	t.rootNode.Insert(key)
+}

bst_test.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBSTCanInsert(t *testing.T) {
+	// Arrange
+	keys := []uint64{10, 5, 15, 30, 20, 25, 35}
+
+	// Act
+	tree := &BinarySearchTree{}
+	for _, key := range keys {
+		tree.Insert(key)
+	}
+
+	// Assert
+	tree.rootNode.Print("", true)
+
+	assert.Equal(t, true, tree.Exists(20), fmt.Sprintf("%d exists", 20))
+
+	for _, key := range keys {
+		assert.Equal(t, true, tree.Exists(key), fmt.Sprintf("%d exists", key))
+	}
+
+	// Hop checker
+	assert.Equal(t, true, tree.Exists(35))
+	assert.Equal(t, 3, tree.LastHopsCheck)
+
+	assert.Equal(t, true, tree.Exists(30))
+	assert.Equal(t, 2, tree.LastHopsCheck)
+
+	assert.Equal(t, false, tree.Exists(36))
+	assert.Equal(t, 3, tree.LastHopsCheck)
+
+	// Tree miss check
+	assert.Equal(t, false, tree.Exists(0))
+	assert.Equal(t, false, tree.Exists(1))
+	assert.Equal(t, false, tree.Exists(9))
+	assert.Equal(t, false, tree.Exists(21))
+	assert.Equal(t, false, tree.Exists(36))
+}

project.todo

@@ -7,4 +7,7 @@ Next Steps:
     ☐ Indexes => Should point records within bin files
         ☐ what index to use is handled by the query optimizer
     - Partition Indexes for relationships
-        ☐ Store FKeys together. Product => Images, Tags
+        ☐ Store FKeys together. Product => Images, Tags
+
+High Level Needs:
+    ☐ Durability against data corruption