Add min and max for binary tree

binaryTree/binaryTree.go

@@ -1,52 +1,60 @@
 package binaryTree
 
-type Comparable func (c1 interface{}, c2 interface{}) bool
+type Comparable func(c1 interface{}, c2 interface{}) bool
 
 type BinaryTree struct {
-    node interface{}
+	node    interface{}
-    left  *BinaryTree
+	left    *BinaryTree
-    right *BinaryTree
+	right   *BinaryTree
-    lessFun Comparable
+	lessFun Comparable
 }
 
 func New(compareFun Comparable) *BinaryTree {
-    tree := &BinaryTree{}
+	return &BinaryTree{
-    tree.node = nil
+		node:    nil,
-    tree.lessFun = compareFun
+		lessFun: compareFun,
-    return tree
+	}
 }
 
 func (tree *BinaryTree) Search(value interface{}) *BinaryTree {
-    if tree.node == nil {
+	if tree.node == nil {
-        return nil
+		return nil
-    }
+	}
-    
+
-    if tree.node == value {
+	if tree.node == value {
-        return tree
+		return tree
-    } else {
+	}
-        if tree.lessFun(value, tree.node) == true {
+	if tree.lessFun(value, tree.node) {
-            t := tree.left.Search(value)
+		return tree.left.Search(value)
-            return t
+	} else {
-        } else {
+		return tree.right.Search(value)
-            t := tree.right.Search(value)
+	}
-            return t
-        }
-    }
 }
 
 func (tree *BinaryTree) Insert(value interface{}) {
-    if tree.node == nil {
+	if tree.node == nil {
-        tree.node = value
+		tree.node = value
-        tree.right = New(tree.lessFun)
+		tree.right = New(tree.lessFun)
-        tree.left  = New(tree.lessFun)
+		tree.left = New(tree.lessFun)
-        return
+		return
-    } else {
+	}
-        if tree.lessFun(value, tree.node) == true {
+	if tree.lessFun(value, tree.node) {
-            tree.left.Insert(value)
+		tree.left.Insert(value)
-        } else {
+	} else {
-            tree.right.Insert(value)
+		tree.right.Insert(value)
-        }
+	}
-    }
 }
 
+func (tree *BinaryTree) Max() interface{} {
+	if tree.node == nil || tree.right.node == nil {
+		return tree.node
+	}
+	return tree.right.Max()
+}
 
+func (tree *BinaryTree) Min() interface{} {
+	if tree.node == nil || tree.left.node == nil {
+		return tree.node
+	}
+	return tree.left.Min()
+}

binaryTree/binaryTree_test.go

@@ -3,28 +3,43 @@ package binaryTree
 import "testing"
 
 func compare(x interface{}, y interface{}) bool {
-    if x.(int) < y.(int) {
+	return x.(int) < y.(int)
-        return true
-    } else {
-        return false
-    }
 }
 
 func Test_binaryTree(t *testing.T) {
-    tree := New(compare)
+	tree := New(compare)
-     
-    tree.Insert(1)
-    tree.Insert(2)
-    tree.Insert(3)
 
-    findTree := tree.Search(2)
+	tree.Insert(1)
+	tree.Insert(2)
+	tree.Insert(3)
+
+	findTree := tree.Search(2)
 	if findTree.node != 2 {
 		t.Error("[Error] Search error")
 	}
 
 	findNilTree := tree.Search(100)
-	
+
 	if findNilTree != nil {
-		t.Error("[Error] 2. Search erro")
+		t.Error("[Error] 2. Search error")
-	} 
+	}
+}
+
+func Test_minmax(t *testing.T) {
+	tree := New(compare)
+
+	testValues := []int{4, 5, 3, 2, 9}
+	for _, i := range testValues {
+		tree.Insert(i)
+	}
+
+	max := tree.Max()
+	if max != 9 {
+		t.Errorf("[Error] max: expected 9, got %d", max)
+	}
+
+	min := tree.Min()
+	if min != 2 {
+		t.Errorf("[Error] max: expected 2, got %d", min)
+	}
 }