剑指Offer07:重建二叉树(Golang/Python/C#)

原题链接：剑指Offer07:重建二叉树(Go语言)

时间复杂度O(n)，空间复杂度O(n)

Golang

package main

type TreeNode struct {
	Val   int
	Left  *TreeNode
	Right *TreeNode
}

func buildTree(preorder []int, inorder []int) *TreeNode {
	if len(preorder) == 0 {
		return nil
	}
	node := &TreeNode{preorder[0], nil, nil}
	index := 0
	for ; index < len(inorder); index++ {
		if preorder[0] == inorder[index] {
			break
		}
	} // 显然没有python的index函数好用！
	leftPre := preorder[1 : index+1]
	leftIn := inorder[:index]
	rightPre := preorder[index+1:]
	rightIn := inorder[index+1:]
	node.Left = buildTree(leftPre, leftIn)
	node.Right = buildTree(rightPre, rightIn)
	return node
}

Python

from typing import List


class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder or not inorder: return
        node = TreeNode(preorder[0])
        index = inorder.index(preorder[0])
        left_pre = preorder[1:index + 1]
        left_in = inorder[:index]
        right_pre = preorder[index + 1:]
        right_in = inorder[index + 1:]
        node.left = self.buildTree(left_pre, left_in)
        node.right = self.buildTree(right_pre, right_in)
        return node

C#

    public class TreeNode
    {
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(int x) { val = x; }
    }

    public class Solution
    {
        public TreeNode BuildTree(int[] preorder, int[] inorder)
        {
            if (preorder.Length == 0 || inorder.Length == 0) return null;
            TreeNode node = new TreeNode(preorder[0]);
            int index = Array.IndexOf(inorder, preorder[0]);
            int[] left_pre = preorder.Skip(1).Take(index + 1).ToArray();
            int[] left_in = inorder.Skip(0).Take(index).ToArray();
            int[] right_pre = preorder.Skip(index + 1).ToArray();
            int[] right_in = inorder.Skip(index + 1).ToArray();
            node.left = BuildTree(left_pre, left_in);
            node.right = BuildTree(right_pre, right_in);
            return node;
        }
    }