@@ -794,6 +794,60 @@ func rebuild(inorder []int, postorder []int, rootIdx int, l, r int) *TreeNode {
794794}
795795```
796796
797+ ``` go
798+ /* *
799+ * Definition for a binary tree node.
800+ * type TreeNode struct {
801+ * Val int
802+ * Left *TreeNode
803+ * Right *TreeNode
804+ * }
805+ */
806+ func buildTree (inorder []int , postorder []int ) *TreeNode {
807+ if len (postorder) == 0 {
808+ return nil
809+ }
810+ 811+ // 后序遍历数组最后一个元素,就是当前的中间节点
812+ rootValue := postorder[len (postorder)-1 ]
813+ root := &TreeNode{Val:rootValue}
814+ 815+ // 叶子结点
816+ if len (postorder) == 1 {
817+ return root
818+ }
819+ 820+ // 找到中序遍历的切割点
821+ var delimiterIndex int
822+ for delimiterIndex = 0 ; delimiterIndex < len (inorder); delimiterIndex++ {
823+ if inorder[delimiterIndex] == rootValue {
824+ break ;
825+ }
826+ }
827+ 828+ // 切割中序数组
829+ // 左闭右开区间:[0, delimiterIndex)
830+ leftInorder := inorder[:delimiterIndex]
831+ // [delimiterIndex + 1, end)
832+ rightInorder := inorder[delimiterIndex+1 :]
833+ 834+ // postorder 舍弃末尾元素
835+ postorder = postorder[:len (postorder)-1 ]
836+ 837+ // 切割后序数组
838+ // 依然左闭右开,注意这里使用了左中序数组大小作为切割点
839+ // [0, len(leftInorder))
840+ leftPostorder := postorder[:len (leftInorder)]
841+ // [len(leftInorder), end)
842+ rightPostorder := postorder[len (leftInorder):]
843+ 844+ root.Left = buildTree (leftInorder, leftPostorder)
845+ root.Right = buildTree (rightInorder, rightPostorder)
846+ 847+ return root
848+ }
849+ ```
850+ 797851105 从前序与中序遍历序列构造二叉树
798852
799853``` go
@@ -829,6 +883,60 @@ func build(pre []int, in []int, root int, l, r int) *TreeNode {
829883}
830884```
831885
886+ ``` go
887+ /* *
888+ * Definition for a binary tree node.
889+ * type TreeNode struct {
890+ * Val int
891+ * Left *TreeNode
892+ * Right *TreeNode
893+ * }
894+ */
895+ func buildTree (preorder []int , inorder []int ) *TreeNode {
896+ if len (preorder) == 0 {
897+ return nil
898+ }
899+ 900+ // 前序遍历数组第一个元素,就是当前的中间节点
901+ rootValue := preorder[0 ]
902+ root := &TreeNode{Val:rootValue}
903+ 904+ // 叶子结点
905+ if len (preorder) == 1 {
906+ return root
907+ }
908+ 909+ // 找到中序遍历的切割点
910+ var delimiterIndex int
911+ for delimiterIndex = 0 ; delimiterIndex < len (inorder); delimiterIndex++ {
912+ if inorder[delimiterIndex] == rootValue {
913+ break
914+ }
915+ }
916+ 917+ // 切割中序数组
918+ // 左闭右开区间:[0, delimiterIndex)
919+ leftInorder := inorder[:delimiterIndex]
920+ // [delimiterIndex + 1, end)
921+ rightInorder := inorder[delimiterIndex+1 :]
922+ 923+ // preorder 舍弃首位元素
924+ preorder = preorder[1 :]
925+ 926+ // 切割前序数组
927+ // 依然左闭右开,注意这里使用了左中序数组大小作为切割点
928+ // [0, len(leftInorder))
929+ leftPreorder := preorder[:len (leftInorder)]
930+ // [len(leftInorder), end)
931+ rightPreorder := preorder[len (leftInorder):]
932+ 933+ root.Left = buildTree (leftPreorder, leftInorder)
934+ root.Right = buildTree (rightPreorder, rightInorder)
935+ 936+ return root
937+ }
938+ ```
939+ 832940
833941### JavaScript
834942
0 commit comments