网易2019面试真题 二叉树的深度

题目描述：求一棵二叉树的深度
输入描述：一直输入有n+1行，第一个数为n，代表二叉树全部节点的个数。后n行每行有两个数字代表父节点左孩子和是否都存在（第二行的两个数代表根节点的孩子是否存在），数字为1时代表孩子存在，-1时代表孩子不存在。节点的顺序根据父节点的情况从左到右，从上至下是排序的。其中n为整数且n<100。
输出描述：输出树的深度

示例1：
输入
2
1 -1
-1 -1
输出
2
思路：求二叉树的深度，使用简单的递归就可以，但是给定输入不是树的形式，所以我的第一个想法使用一维数组将输入存起来，然后将一维数组转化为二叉树，但是我又发现给定的树是不完全二叉树，所以我把1和-1当作树的节点的值，把一位数组先转化为完全二叉树，然后根据节点的值是否为-1进行剪枝，最后使用递归得到树的深度。代码如下：

import sys
class Treenode:
    def __init__(self, data, left, right):
        self.val = data
        self.left = left
        self.right = right
        
class Solution:
    def  build_tree(self, arr):
        node_list = []
        for i in range(len(arr)):
            node = Treenode(arr[i], None, None)
            node_list.append(node)
            
        if len(node_list) > 0:
            for i in range(int(len(arr)/2)-1):
                if node_list[2*i + 1].left is None:
                    node_list[i].left = node_list[2*i+1]
                if node_list[2*i + 2].right is None:
                    node_list[i].right = node_list[2*i +2]
                    
            last_idx = int(len(arr)/2) - 1
            node_list[last_idx].left = node_list[last_idx * 2 +1]
            if len(arr) % 2 == 1:
                 node_list[last_idx].right = node_list[last_idx * 2 + 2]
        return node_list
        
    def print_all(self, node):#剪枝
        if node.left is not None and node.left.val == -1:
           node.left = None
        if node.right is not None and node.right.val == -1:
            node.right = None
        self.print_all(node.left)
        self.print_all(node.right)
        
    def finddepth(self,phead):
        if phead == None:
            return 0
        else:
            # 递归寻找
            return max(1+self.finddepth(phead.left),1+self.finddepth(phead.right))
            
loop = int(sys.stdin.readline().strip())
arr = []
arr.append(1)
node_list = []
for i in range(loop):    
    m, n = [int(x) for x in sys.stdin.readline().strip().split()]
    arr.append(m)
    arr.append(n)
print(arr)
a = Solution()
node_list = a.build_tree(arr)
a.print_all(node_list[0])
print(a.finddepth(node_list[0]))

但是在写数组转二叉树部分的代码的时候我发现，既然我都知道了每一层树是从哪个节点开始的，到哪个节点结束，我直接统计这个区间内有没有1不就可以了？有1深度加1。我首先根据数组转二叉树的过程写了一版，build_tree，但是还是较为复杂，需要很多标志位，逻辑也不清晰，代码可读性差。之后又写了一版简化的，build_tree2，逻辑清晰，代码量也小。两版代码如下：

import sys
class Solution:
    def  build_tree(self, arr):
        count = 0
        layer = 0
        flag = 0
        if len(arr) > 0:
            for i in range(int(len(arr)/2)-1):
                if i > layer:
                    layer = layer * 2
                    flag = 0
                if arr[2*i + 1] != -1 or arr[2*i + 2] != -1:
                    if flag == 0:
                        count += 1
                        flag = 1         
            last_idx = int(len(arr)/2) - 1
            flag2 = 0
            if flag == 0 and arr[last_idx * 2 +1] != -1:
                count += 1
                flag = 1
            if len(arr) % 2 == 1:
                if flag == 0 and arr[last_idx * 2 +2] != -1 and flag2 == 0:
                    count += 1
        return count
    def  build_tree2(self, arr):
        layer = 0
        depth = 0
        while layer < len(arr):
            nex = layer * 2
            if nex >= len(arr):
                nex = len(arr)-1
            for i in range(layer, nex+1):
                if arr[i] == 1:
                    depth += 1
                    break
            layer = layer * 2 + 1
        return depth
loop = int(sys.stdin.readline().strip())
arr = []
arr.append(1)
node_list = []
for i in range(loop):    
    m, n = [int(x) for x in sys.stdin.readline().strip().split()]
    arr.append(m)
    arr.append(n)
print(arr)
a = Solution()
print(a.build_tree2(arr))