leetCode题目--二叉树的最大深度

题目

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例 

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

python代码的实现：(非递归）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        length = 0
        if root == None:
            return length
        myQueue = []
        node = root
        myQueue.append((1, node))
        while myQueue:
            c_depth, node = myQueue.pop(0)
            if node is not None:
                length = max(length, c_depth)
                myQueue.append((c_depth + 1, node.left))
                myQueue.append((c_depth + 1, node.right))
           
        return length

树的基本操作代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# author:1111
# datetime:2019/8/28 21:27
# software: PyCharm
# Definition for a binary tree node.
"""
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
返回它的最大深度 3 。
"""
class TreeNode(object):
    def __init__(self, x=-1):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    import math
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        length = 0
        if root == None:
            return length
        myQueue = []
        node = root
        myQueue.append((1, node))
        while myQueue:
            c_depth, node = myQueue.pop(0)
            if node is not None:
                length = max(length, c_depth)
                myQueue.append((c_depth + 1, node.left))
                myQueue.append((c_depth + 1, node.right))
            # if node.left != None and node.right != None:
            #     length = length + 1
            #     myQueue.append(node.left)
            #     myQueue.append(node.right)
            # if node.left != None :
            #     length1 = length1 + 1
            #     myQueue.append(node.left)
            # if node.right != None :
            #     length2= length2 + 1
            #     myQueue.append(node.right)

            # elif node.right != None :
            #     length = length + 1
            #     myQueue.append(node.right)
        print(length)

        # stack = []
        # if root is not None:
        #     stack.append((1, root))
        #
        # depth = 0
        # while stack != []:
        #     current_depth, root = stack.pop()
        #     if root is not None:
        #         depth = max(depth, current_depth)
        #         stack.append((current_depth + 1, root.left))
        #         stack.append((current_depth + 1, root.right))
        return length

class Tree(object):
    """树类"""
    def __init__(self):
        self.root = TreeNode()
        self.myQueue = []

    def add(self, elem):
        """为树添加节点"""
        node = TreeNode(elem)
        if self.root.val == -1:  # 如果树是空的，则对根节点赋值
            self.root = node
            self.myQueue.append(self.root)
        else:
            treeNode = self.myQueue[0]  # 此结点的子树还没有齐。
            if treeNode.left == None:
                treeNode.left = node
                self.myQueue.append(treeNode.left)
            else:
                treeNode.right = node
                self.myQueue.append(treeNode.right)
                self.myQueue.pop(0)  # 如果该结点存在右子树，将此结点丢弃。

    def front_digui(self, root):
        """利用递归实现树的先序遍历"""
        if root == None:
            return
        print (root.val)
        self.front_digui(root.left)
        self.front_digui(root.right)


    def middle_digui(self, root):
        """利用递归实现树的中序遍历"""
        if root == None:
            return
        self.middle_digui(root.left)
        print (root.val)
        self.middle_digui(root.right)


    def later_digui(self, root):
        """利用递归实现树的后序遍历"""
        if root == None:
            return
        self.later_digui(root.left)
        self.later_digui(root.right)
        print (root.val)

    def front_stack(self, root):
        """利用堆栈实现树的先序遍历"""
        if root == None:
            return
        myStack = []
        node = root
        while node or myStack:
            while node:  #从根节点开始，一直找它的左子树
                print (node.val)
                myStack.append(node)
                node = node.left
            node = myStack.pop()#while结束表示当前节点node为空，即前一个节点没有左子树了
            node = node.right   #开始查看它的右子树


    def middle_stack(self, root):
        """利用堆栈实现树的中序遍历"""
        if root == None:
            return
        myStack = []
        node = root
        while node or myStack:
            while node:    #从根节点开始，一直找它的左子树
                myStack.append(node)
                node = node.left
            node = myStack.pop()            #while结束表示当前节点node为空，即前一个节点没有左子树了
            print (node.val)
            node = node.rchild                  #开始查看它的右子树


    def later_stack(self, root):
        """利用堆栈实现树的后序遍历"""
        if root == None:
            return
        myStack1 = []
        myStack2 = []
        node = root
        myStack1.append(node)
        while myStack1:                   #这个while循环的功能是找出后序遍历的逆序，存在myStack2里面
            node = myStack1.pop()
            if node.lchild:
                myStack1.append(node.left)
            if node.rchild:
                myStack1.append(node.right)
            myStack2.append(node)
        while myStack2:                         #将myStack2中的元素出栈，即为后序遍历次序
            print (myStack2.pop().val)


    def level_queue(self, root):
        """利用队列实现树的层次遍历"""
        if root == None:
            return
        myQueue = []
        node = root
        myQueue.append(node)
        while myQueue:
            node = myQueue.pop(0)
            print (node.val)
            if node.left != None:
                myQueue.append(node.left)
            if node.right != None:
                myQueue.append(node.right)


if __name__ == '__main__':
    """主函数"""
    elems = range(10)           #生成十个数据作为树节点
    tree = Tree()          #新建一个树对象
    for elem in elems:
        tree.add(elem)
    s = Solution()
    s.maxDepth(tree.root)
    # print ('队列实现层次遍历:')
    # tree.level_queue(tree.root)
    #
    # print ('\n\n递归实现先序遍历:')
    # tree.front_digui(tree.root)
    # print ('\n递归实现中序遍历:')
    # tree.middle_digui(tree.root)
    # print ('\n递归实现后序遍历:')
    # tree.later_digui(tree.root)

    # print ('\n\n堆栈实现先序遍历:')
    # tree.front_stack(tree.root)
    # print ('\n堆栈实现中序遍历:')
    # tree.middle_stack(tree.root)
    # print ('\n堆栈实现后序遍历:')
    # tree.later_stack(tree.root)