From 180cb912c68c4d2da3d8fd64e982a028e8144999 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=96=87=E6=B2=BB=EF=BC=88=E6=B2=BB=EF=BC=89?=
 <2271034209@qq.com>
Date: Sat, 14 Jan 2023 03:17:54 +0800
Subject: [PATCH] Add new file

---
 datastructure/treenode.go | 171 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 datastructure/treenode.go

diff --git a/datastructure/treenode.go b/datastructure/treenode.go
new file mode 100644
index 0000000..6fccd4b
--- /dev/null
+++ b/datastructure/treenode.go
@@ -0,0 +1,171 @@
+package datastructure
+
+import (
+	"strconv"
+	"strings"
+)
+
+// TreeNode 二叉树结构 Definition for a binary tree node.
+type TreeNode struct {
+	Val int
+	Left *TreeNode
+	Right *TreeNode
+}
+
+/*
+二叉树转一维数组: 二叉树遍历(前中后)
+*/
+
+// PreorderTraversal 144. 二叉树的前序遍历
+func PreorderTraversal(root *TreeNode) (vales []int) {
+	var preorder func(*TreeNode)
+	preorder = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		vales = append(vales, node.Val)
+		preorder(node.Left)
+		preorder(node.Right)
+	}
+	preorder(root)
+	return
+}
+
+// PostorderTraversal 145. 二叉树的后序遍历
+func PostorderTraversal(root *TreeNode) (res []int) {
+	var postorder func(*TreeNode)
+	postorder = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		postorder(node.Left)
+		postorder(node.Right)
+		res = append(res, node.Val)
+	}
+	postorder(root)
+	return
+}
+
+// InorderTraversal 94. 二叉树的中序遍历
+func InorderTraversal(root *TreeNode) (res []int) {
+	var inorder func(node *TreeNode)
+	inorder = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		inorder(node.Left)
+		res = append(res, node.Val)
+		inorder(node.Right)
+	}
+	inorder(root)
+	return
+}
+
+/*
+一维整形数组转二叉树)
+*/
+
+// BstFromPreorder 1008. 前序遍历构造二叉搜索树 (一维整形数组转二叉树)
+func BstFromPreorder(preorder []int) *TreeNode {
+	if divide := len(preorder); divide > 0 {
+		for i, val := range preorder {
+			if val > preorder[0] {
+				divide = i
+				break
+			}
+		}
+		return &TreeNode{
+			Val: preorder[0],
+			Left: BstFromPreorder(preorder[1:divide]),
+			Right: BstFromPreorder(preorder[divide: ]),
+		}
+	}
+	return nil
+}
+
+/*
+二叉树转二维数组（层序遍历）
+*/
+
+// LevelOrder 102. 二叉树的层序遍历
+func LevelOrder(root *TreeNode) [][]int {
+	var ret [][]int
+	if root == nil {
+		return ret
+	}
+	q := []*TreeNode{root}
+	for i := 0; len(q) > 0; i++ {
+		ret = append(ret, []int{})
+		var p []*TreeNode
+		for j := 0; j < len(q); j++ {
+			node := q[j]
+			ret[i] = append(ret[i], node.Val)
+			if node.Left != nil {
+				p = append(p, node.Left)
+			}
+			if node.Right != nil {
+				p = append(p, node.Right)
+			}
+		}
+		q = p
+	}
+	return ret
+}
+
+/*
+字符串转二叉树
+*/
+
+// StringToTreeNode 字符串转二叉树
+func StringToTreeNode(input string) (root *TreeNode) {
+	s := strings.TrimLeft(input, "[")
+	s = strings.TrimRight(s, "]")
+
+	arr := strings.Split(s, ",")
+	if len(arr) == 0 || arr[0] == "null" {
+		return
+	}
+
+	root = new(TreeNode)
+	root.Val, _ = strconv.Atoi(arr[0])
+	arr = arr[1:]
+	queue := []*TreeNode {root}
+	for len(queue) > 0 && len(arr) > 0 {
+		node := queue[0]
+		queue := queue[1:]
+
+		if arr[0] != "null" {
+			node.Left = new(TreeNode)
+			node.Left.Val, _ = strconv.Atoi(arr[0])
+			queue = append(queue, node.Left)
+		}
+		arr = arr[1:]
+		if len(arr) > 0 {
+			if arr[0] != "null" {
+				node.Right = new(TreeNode)
+				node.Right.Val, _ = strconv.Atoi(arr[0])
+				queue = append(queue, node.Right)
+			}
+			arr = arr[1:]
+		}
+	}
+	// root 可写可不写
+	return
+
+	////input = input[1:-1] 报错
+	//rs := []rune(input)
+	//input = string(rs[1:len(input)-1])
+	//// input != nil 报错
+	//if  len(input) == 0 {
+	//	return
+	//}
+	//
+	//inputValues := strings.Split(input, ",")
+	//for i := 0; i < len(inputValues); i++ {
+	//	inputValues[i] = strings.Trim(inputValues[i], "")
+	//}
+	//
+	//// int: strconv.Atoi(inputValues[0])
+	//// int64: strconv.ParseInt(inputValues[0])
+	//root := TreeNode(strconv.Atoi(inputValues[0])) // TreeNode 报错？？
+}
-- 
GitLab