Diameter of Binary tree + Balanced binary tree

Author: volodimyr

110.balanced_binary_tree/balanced.go

@@ -0,0 +1,61 @@
+// 110. Balanced binary tree
+// Topics: 'Tree', 'Binary Tree', 'Depth-First Search'
+
+// Given a binary tree, determine if it is
+
+// Example 1:
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: true
+
+// Example 2:
+
+// Input: root = [1,2,2,3,3,null,null,4,4]
+// Output: false
+
+// Example 3:
+
+// Input: root = []
+// Output: true
+
+// Constraints:
+
+//     The number of nodes in the tree is in the range [0, 5000].
+//     -104 <= Node.val <= 104
+
+package balancedbinarytree
+
+type TreeNode struct {
+	Right *TreeNode
+	Left  *TreeNode
+	Val   int
+}
+
+func isBalanced(root *TreeNode) bool {
+	return height(root) != -1
+}
+
+func height(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	left := height(root.Left)
+	if left == -1 {
+		return left
+	}
+	right := height(root.Right)
+	if right == -1 {
+		return right
+	}
+	if abs(left-right) > 1 {
+		return -1
+	}
+	return max(left, right) + 1
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

110.balanced_binary_tree/balanced_test.go

@@ -0,0 +1,186 @@
+package balancedbinarytree
+
+import "testing"
+
+func TestIsBalanced(t *testing.T) {
+	tests := []struct {
+		name string
+		root *TreeNode
+		want bool
+	}{
+		{
+			name: "balanced with deeper left subtree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val:  4,
+						Left: &TreeNode{Val: 8},
+					},
+					Right: &TreeNode{Val: 5},
+				},
+				Right: &TreeNode{
+					Val:  3,
+					Left: &TreeNode{Val: 6},
+				},
+			},
+			want: true,
+		},
+		{
+			name: "example 1 - balanced tree",
+			root: &TreeNode{
+				Val:  3,
+				Left: &TreeNode{Val: 9},
+				Right: &TreeNode{
+					Val:   20,
+					Left:  &TreeNode{Val: 15},
+					Right: &TreeNode{Val: 7},
+				},
+			},
+			want: true,
+		},
+		{
+			name: "example 2 - unbalanced tree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val:  3,
+						Left: &TreeNode{Val: 4},
+					},
+					Right: &TreeNode{
+						Val:   3,
+						Right: &TreeNode{Val: 4},
+					},
+				},
+				Right: &TreeNode{Val: 2},
+			},
+			want: false,
+		},
+		{
+			name: "example 3 - empty tree",
+			root: nil,
+			want: true,
+		},
+		{
+			name: "single node",
+			root: &TreeNode{Val: 1},
+			want: true,
+		},
+		{
+			name: "left skewed unbalanced",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val: 3,
+					},
+				},
+			},
+			want: false,
+		},
+		{
+			name: "right skewed unbalanced",
+			root: &TreeNode{
+				Val: 1,
+				Right: &TreeNode{
+					Val: 2,
+					Right: &TreeNode{
+						Val: 3,
+					},
+				},
+			},
+			want: false,
+		},
+		{
+			name: "two nodes left",
+			root: &TreeNode{
+				Val:  1,
+				Left: &TreeNode{Val: 2},
+			},
+			want: true,
+		},
+		{
+			name: "two nodes right",
+			root: &TreeNode{
+				Val:   1,
+				Right: &TreeNode{Val: 2},
+			},
+			want: true,
+		},
+		{
+			name: "complete binary tree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Left:  &TreeNode{Val: 4},
+					Right: &TreeNode{Val: 5},
+				},
+				Right: &TreeNode{
+					Val:   3,
+					Left:  &TreeNode{Val: 6},
+					Right: &TreeNode{Val: 7},
+				},
+			},
+			want: true,
+		},
+		{
+			name: "balanced with different heights",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 3},
+				},
+				Right: &TreeNode{Val: 4},
+			},
+			want: true,
+		},
+		{
+			name: "unbalanced subtree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val: 2,
+					Left: &TreeNode{
+						Val:  3,
+						Left: &TreeNode{Val: 4},
+					},
+				},
+				Right: &TreeNode{
+					Val:  5,
+					Left: &TreeNode{Val: 6},
+				},
+			},
+			want: false,
+		},
+		{
+			name: "balanced asymmetric tree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:   2,
+					Right: &TreeNode{Val: 3},
+				},
+				Right: &TreeNode{
+					Val:  4,
+					Left: &TreeNode{Val: 5},
+				},
+			},
+			want: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := isBalanced(tt.root)
+			if got != tt.want {
+				t.Errorf("isBalanced() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

543.diameter_of_binary_tree/diameter.go

@@ -0,0 +1,48 @@
+// 543. Diameter of Binary tree
+// Topics: 'Tree', 'Binary Tree', 'Depth-First Search'
+
+// Given the root of a binary tree, return the length of the diameter of the tree.
+
+// The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.
+
+// The length of a path between two nodes is represented by the number of edges between them.
+
+// Example 1:
+
+// Input: root = [1,2,3,4,5]
+// Output: 3
+// Explanation: 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+
+// Example 2:
+
+// Input: root = [1,2]
+// Output: 1
+
+// Constraints:
+
+//     The number of nodes in the tree is in the range [1, 104].
+//     -100 <= Node.val <= 100
+
+package diameterofbinarytree
+
+func diameterOfBinaryTree(root *TreeNode) int {
+	var max int
+	diameter(root, &max)
+	return max
+}
+
+func diameter(root *TreeNode, m *int) int {
+	if root == nil {
+		return 0
+	}
+	left := diameter(root.Left, m)
+	right := diameter(root.Right, m)
+	*m = max(*m, left+right)
+	return max(left, right) + 1
+}
+
+type TreeNode struct {
+	Right *TreeNode
+	Left  *TreeNode
+	Val   int
+}