level order traversal

Author: volodimyr

102.binary_tree_level_order_traversal/level_order_traversal.go

@@ -0,0 +1,59 @@
+// 102. Binary tree level order traversal
+// Topics: 'Breadth-First Search', 'Tree', 'Binary Tree'
+// Level: 'Medium'
+
+// Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
+
+// Example 1:
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: [[3],[9,20],[15,7]]
+
+// Example 2:
+
+// Input: root = [1]
+// Output: [[1]]
+
+// Example 3:
+
+// Input: root = []
+// Output: []
+
+// Constraints:
+
+//     The number of nodes in the tree is in the range [0, 2000].
+//     -1000 <= Node.val <= 1000
+
+package binarytreelevelordertraversal
+
+func levelOrder(root *TreeNode) [][]int {
+	var lvl int
+	arr := [][]int{}
+	if root == nil {
+		return arr
+	}
+	q := []*TreeNode{root}
+
+	for len(q) != 0 {
+		arr = append(arr, make([]int, len(q)))
+		for i := range len(q) {
+			tn := q[0]
+			q = q[1:]
+			arr[lvl][i] = tn.Val
+			if tn.Left != nil {
+				q = append(q, tn.Left)
+			}
+			if tn.Right != nil {
+				q = append(q, tn.Right)
+			}
+		}
+		lvl++
+	}
+	return arr
+}
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}

102.binary_tree_level_order_traversal/level_order_traversal_test.go

@@ -0,0 +1,127 @@
+package binarytreelevelordertraversal
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestLevelOrder(t *testing.T) {
+	tests := []struct {
+		name string
+		root *TreeNode
+		want [][]int
+	}{
+		{
+			name: "example 1: tree with three levels",
+			root: &TreeNode{
+				Val:  3,
+				Left: &TreeNode{Val: 9},
+				Right: &TreeNode{
+					Val:   20,
+					Left:  &TreeNode{Val: 15},
+					Right: &TreeNode{Val: 7},
+				},
+			},
+			want: [][]int{{3}, {9, 20}, {15, 7}},
+		},
+		{
+			name: "example 2: single node",
+			root: &TreeNode{Val: 1},
+			want: [][]int{{1}},
+		},
+		{
+			name: "example 3: empty tree",
+			root: nil,
+			want: [][]int{},
+		},
+		{
+			name: "left skewed tree",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 3},
+				},
+			},
+			want: [][]int{{1}, {2}, {3}},
+		},
+		{
+			name: "right skewed tree",
+			root: &TreeNode{
+				Val: 1,
+				Right: &TreeNode{
+					Val:   2,
+					Right: &TreeNode{Val: 3},
+				},
+			},
+			want: [][]int{{1}, {2}, {3}},
+		},
+		{
+			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: [][]int{{1}, {2, 3}, {4, 5, 6, 7}},
+		},
+		{
+			name: "tree with negative values",
+			root: &TreeNode{
+				Val:   -1,
+				Left:  &TreeNode{Val: -2},
+				Right: &TreeNode{Val: -3},
+			},
+			want: [][]int{{-1}, {-2, -3}},
+		},
+		{
+			name: "tree with mixed positive and negative values",
+			root: &TreeNode{
+				Val:   0,
+				Left:  &TreeNode{Val: -1000},
+				Right: &TreeNode{Val: 1000},
+			},
+			want: [][]int{{0}, {-1000, 1000}},
+		},
+		{
+			name: "unbalanced tree with only left children at second level",
+			root: &TreeNode{
+				Val: 1,
+				Left: &TreeNode{
+					Val:  2,
+					Left: &TreeNode{Val: 4},
+				},
+				Right: &TreeNode{
+					Val:  3,
+					Left: &TreeNode{Val: 5},
+				},
+			},
+			want: [][]int{{1}, {2, 3}, {4, 5}},
+		},
+		{
+			name: "two level tree with one child each",
+			root: &TreeNode{
+				Val:  10,
+				Left: &TreeNode{Val: 20},
+			},
+			want: [][]int{{10}, {20}},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := levelOrder(tt.root)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("levelOrder() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}