Binary Tree

algorithms/binary_tree.go

@@ -0,0 +1,17 @@
+package algorithms
+
+import "github.com/dimitrijjedich/go-algorithms/helper"
+
+func BinaryTreeSort(arr []int) []int {
+	n := len(arr)
+	result := make([]int, n)
+	tree := helper.Tree{}
+
+	for i := 0; i < len(arr); i++ {
+		tree.Insert(arr[i])
+	}
+	if tree.Root != nil {
+		result = tree.Root.Walk()
+	}
+	return result
+}

algorithms_test/binary_tree_test.go

@@ -0,0 +1,33 @@
+package algorithms_test
+
+import (
+	"github.com/dimitrijjedich/go-algorithms/algorithms"
+	"reflect"
+	"testing"
+)
+
+func TestBinaryTreeSort(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    []int
+		expected []int
+	}{
+		{"already sorted", []int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
+		{"reverse sorted", []int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
+		{"unsorted array", []int{5, 3, 8, 6, 2}, []int{2, 3, 5, 6, 8}},
+		{"non consecutive array", []int{9, 3, 5, 1, 7}, []int{1, 3, 5, 7, 9}},
+		{"empty array", []int{}, []int{}},
+		{"single element", []int{42}, []int{42}},
+		{"duplicates", []int{3, 1, 2, 3, 1}, []int{1, 1, 2, 3, 3}},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			result := algorithms.BinaryTreeSort(testCase.input)
+
+			if !reflect.DeepEqual(result, testCase.expected) {
+				t.Errorf("Failed %s: expected %v, got %v", testCase.name, testCase.expected, result)
+			}
+		})
+	}
+}

helper/node.go

@@ -0,0 +1,35 @@
+package helper
+
+type Node struct {
+	data  int
+	left  *Node
+	right *Node
+}
+
+func (node *Node) insert(newNode *Node) {
+	if newNode.data < node.data && node.left == nil {
+		node.left = newNode
+	} else if newNode.data < node.data {
+		node.left.insert(newNode)
+	} else if node.right == nil {
+		node.right = newNode
+	} else {
+		node.right.insert(newNode)
+	}
+}
+
+func (node *Node) Walk() []int {
+	result := make([]int, 0)
+	result = append(result, node.data)
+	if node.left == nil {
+		if node.right != nil {
+			result = append(result, node.right.Walk()...)
+		}
+	} else {
+		result = append(node.left.Walk(), result...)
+		if node.right != nil {
+			result = append(result, node.right.Walk()...)
+		}
+	}
+	return result
+}

helper/tree.go

@@ -0,0 +1,15 @@
+package helper
+
+type Tree struct {
+	Root *Node
+}
+
+func (tree *Tree) Insert(data int) *Tree {
+	newNode := &Node{data: data, left: nil, right: nil}
+	if tree.Root != nil {
+		tree.Root.insert(newNode)
+	} else {
+		tree.Root = newNode
+	}
+	return tree
+}