feat(solutions): add binary_tree_zigzag_level_order_traversal

Author: WindomZ

README.md

@@ -34,6 +34,7 @@ If you like it then you can put a :star:**Star** on it.
 
 | # | **Problem** & **Solution** | Difficulty | Single Repetition Duration | LeetCode Run Time |
 | ---: | :----- | :----------: | ----------: | ----------: |
+|[103][Solutions-103]|[Binary Tree Zigzag Level Order Traversal][Solutions-103-Home]|Medium|[78.6 ns/op][Solutions-103-Code] / [3 test cases][Solutions-103-Test]|0 ms|
 |[102][Solutions-102]|[Binary Tree Level Order Traversal][Solutions-102-Home]|Medium|[76.0 ns/op][Solutions-102-Code] / [3 test cases][Solutions-102-Test]|8 ms|
 |[101][Solutions-101]|[Symmetric Tree][Solutions-101-Home]|Easy|[17.6 ns/op][Solutions-101-Code] / [5 test cases][Solutions-101-Test]|4 ms|
 |[100][Solutions-100]|[Same Tree][Solutions-100-Home]|Easy|[9.12 ns/op][Solutions-100-Code] / [6 test cases][Solutions-100-Test]|0 ms|
@@ -158,6 +159,10 @@ Welcome to report bugs, suggest ideas and discuss on [issues page](https://githu
 ## License
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FWindomZ%2Fleetcode.go.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FWindomZ%2Fleetcode.go?ref=badge_large)
 
+[Solutions-103]:https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
+[Solutions-103-Home]:solutions/binary_tree_zigzag_level_order_traversal/
+[Solutions-103-Code]:solutions/binary_tree_zigzag_level_order_traversal/binarytreezigzaglevelordertraversal.go
+[Solutions-103-Test]:solutions/binary_tree_zigzag_level_order_traversal/binarytreezigzaglevelordertraversal_test.go#L62
 [Solutions-102]:https://leetcode.com/problems/binary-tree-level-order-traversal/
 [Solutions-102-Home]:solutions/binary_tree_level_order_traversal/
 [Solutions-102-Code]:solutions/binary_tree_level_order_traversal/binarytreelevelordertraversal.go

solutions/binary_tree_zigzag_level_order_traversal/NOTE_Ch-zh.md

@@ -0,0 +1,4 @@
+# 解法要点
+1. 运用递归遍历解法思想
+1. 利用层级参数，遍历累计各层级的值
+1. 奇数层级，值倒序处理

solutions/binary_tree_zigzag_level_order_traversal/README.md

@@ -0,0 +1,32 @@
+# [103. Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/description/)
+
+## Description
+
+Given a binary tree, return the _zigzag level order_ traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).
+
+For example:  
+
+Given binary tree `[3,9,20,null,null,15,7]`,  
+```
+    3
+   / \
+  9  20
+    /  \
+   15   7
+```
+
+return its zigzag level order traversal as:  
+```
+[
+  [3],
+  [20,9],
+  [15,7]
+]
+```
+
+## Solution
+- [Code](binarytreezigzaglevelordertraversal.go)
+- [Testing](binarytreezigzaglevelordertraversal_test.go)
+
+## Note
+- [中文](NOTE_Ch-zh.md)

solutions/binary_tree_zigzag_level_order_traversal/binarytreezigzaglevelordertraversal.go

@@ -0,0 +1,37 @@
+package binarytreezigzaglevelordertraversal
+
+// TreeNode definition for a binary tree node.
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func zigzagLevelOrder(root *TreeNode) [][]int {
+	if root == nil {
+		return [][]int{}
+	}
+	level := make([][]int, 0, 4)
+	zigzagOrder(root, &level, 0)
+	for depth, nodes := range level {
+		if depth%2 != 0 { // right to left traversal
+			l := len(nodes)
+			for i := 0; i < l/2; i++ {
+				nodes[i], nodes[l-i-1] = nodes[l-i-1], nodes[i]
+			}
+		}
+	}
+	return level
+}
+
+func zigzagOrder(root *TreeNode, level *[][]int, depth int) {
+	if root == nil {
+		return
+	}
+	if len(*level) <= depth {
+		*level = append(*level, make([]int, 0, depth*2))
+	}
+	(*level)[depth] = append((*level)[depth], root.Val) // level[depth] append the value of node
+	zigzagOrder(root.Left, level, depth+1)              // left traversal
+	zigzagOrder(root.Right, level, depth+1)             // right traversal
+}

solutions/binary_tree_zigzag_level_order_traversal/binarytreezigzaglevelordertraversal_test.go

@@ -0,0 +1,89 @@
+package binarytreezigzaglevelordertraversal
+
+import (
+	"testing"
+
+	"github.com/WindomZ/testify/assert"
+)
+
+func Test_zigzagLevelOrder(t *testing.T) {
+	assert.Equal(t, [][]int{}, zigzagLevelOrder(nil))
+	assert.Equal(t,
+		[][]int{
+			{1},
+		}, zigzagLevelOrder(&TreeNode{
+			Val: 1,
+		}))
+	assert.Equal(t,
+		[][]int{
+			{3},
+			{20, 9},
+			{15, 7},
+		}, zigzagLevelOrder(&TreeNode{
+			Val: 3,
+			Left: &TreeNode{
+				Val: 9,
+			},
+			Right: &TreeNode{
+				Val: 20,
+				Left: &TreeNode{
+					Val: 15,
+				},
+				Right: &TreeNode{
+					Val: 7,
+				},
+			},
+		}))
+	assert.Equal(t,
+		[][]int{
+			{3},
+			{20, 9},
+			{11, 15, 7},
+		}, zigzagLevelOrder(&TreeNode{
+			Val: 3,
+			Left: &TreeNode{
+				Val: 9,
+				Right: &TreeNode{
+					Val: 11,
+				},
+			},
+			Right: &TreeNode{
+				Val: 20,
+				Left: &TreeNode{
+					Val: 15,
+				},
+				Right: &TreeNode{
+					Val: 7,
+				},
+			},
+		}))
+}
+
+func Benchmark_zigzagLevelOrder(b *testing.B) {
+	b.StopTimer()
+	b.ReportAllocs()
+	b.StartTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			zigzagLevelOrder(nil)
+			zigzagLevelOrder(&TreeNode{
+				Val: 1,
+			})
+			zigzagLevelOrder(&TreeNode{
+				Val: 3,
+				Left: &TreeNode{
+					Val: 9,
+				},
+				Right: &TreeNode{
+					Val: 20,
+					Left: &TreeNode{
+						Val: 15,
+					},
+					Right: &TreeNode{
+						Val: 7,
+					},
+				},
+			})
+		}
+	})
+}