Add problem 4 of chapter 4

src/chapter4/binary_tree_node.go

@@ -0,0 +1,21 @@
+package chapter4
+
+// BTNode represents a node in binary tree
+type BTNode struct {
+	Value  int
+	Parent *BTNode
+	Left   *BTNode
+	Right  *BTNode
+}
+
+// SetRight sets child on right side
+func (n *BTNode) SetRight(c *BTNode) {
+	n.Right = c
+	c.Parent = n
+}
+
+// SetLeft sets child on right side
+func (n *BTNode) SetLeft(c *BTNode) {
+	n.Left = c
+	c.Parent = n
+}

src/chapter4/problem4.go

@@ -0,0 +1,34 @@
+package chapter4
+
+import "math"
+
+// CheckBalanced checks if given tree is balanced
+func CheckBalanced(root *BTNode) bool {
+	return CheckBalancedR(root) != math.MinInt64
+}
+
+// CheckBalancedR checks if  given tree is balanced by checking depth
+// It returns math.MinInt64 if it's not balanced
+func CheckBalancedR(node *BTNode) int64 {
+	if node == nil {
+		return -1
+	}
+
+	leftD := CheckBalancedR(node.Left)
+	if leftD == math.MinInt64 {
+		return math.MinInt64
+	}
+
+	rightD := CheckBalancedR(node.Right)
+	if rightD == math.MinInt64 {
+		return math.MinInt64
+	}
+
+	if diff := leftD - rightD; diff < -1 || diff > 1 {
+		return math.MinInt64
+	}
+	if rightD < leftD {
+		return leftD + 1
+	}
+	return rightD + 1
+}

src/chapter4/problem4_test.go

@@ -0,0 +1,53 @@
+package chapter4
+
+import "testing"
+
+func TestCheckBalanced(t *testing.T) {
+	tests := map[string]struct {
+		in  *BTNode
+		out bool
+	}{
+
+		"Should return true when tree only has a single node": {
+			in:  &BTNode{},
+			out: true,
+		},
+
+		"Should return true when difference of height of subtree is less than or equal to 1": {
+			in: &BTNode{
+				Right: &BTNode{
+					Right: &BTNode{},
+				},
+				Left: &BTNode{},
+			},
+			out: true,
+		},
+
+		"Should return false when difference of height of subtree is greater than 1": {
+			in: &BTNode{
+				Right: &BTNode{
+					Right: &BTNode{
+						Right: &BTNode{},
+						Left:  &BTNode{},
+					},
+				},
+				Left: &BTNode{},
+			},
+			out: false,
+		},
+
+		"Should return true when tree is nil": {
+			in:  nil,
+			out: true,
+		},
+	}
+
+	for k, test := range tests {
+		t.Run(k, func(t *testing.T) {
+			out := CheckBalanced(test.in)
+			if out != test.out {
+				t.Errorf("actual=%t expected=%t", out, test.out)
+			}
+		})
+	}
+}