二叉树的遍历与深度计算（python实现）

 

二叉树作为一种重要的数据结构，也是面试中经常会问到的。其中，二叉树的遍历和深度计算更是重中之重。

二叉树的遍历

分为深度优先遍历和广度优先遍历两类。其中，

深度优先遍历，

根据遍历顺序的不同可以细分为：前序遍历、中序遍历、后序遍历

广度优先遍历，

就是常规意义上按照层次从上到下，依次进行遍历。

二叉树深度计算

即为求取二叉树的最大深度

python实现：

class TreeNode:
    def __init__(self, value=None, left=None, right=None):
        self.value = value
        self.left = left  # 左子树
        self.right = right  # 右子树


class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        # 使用层次遍历
        # 当树为空直接返回0
        if pRoot is None:
            return 0
        # 使用递归
        # 如果该树只有一个结点，它的深度为1.如果根节点只有左子树没有右子树，
        # 那么树的深度为左子树的深度加1；同样，如果只有右子树没有左子树，
        # 那么树的深度为右子树的深度加1。如果既有左子树也有右子树，
        # 那该树的深度就是左子树和右子树的最大值加1.
        return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right)) + 1

    # 前序遍历
    # 遍历顺序 --> 根节点 -> 左子树 -> 右子树
    def preTraverse(self, pRoot):
        if pRoot is None:
            return
        print(pRoot.value)
        self.preTraverse(pRoot.left)
        self.preTraverse(pRoot.right)

    # 中序遍历
    # 遍历顺序--> 左子树 -> 根节点 -> 右子树
    def midTraverse(self, pRoot):
        if pRoot is None:
            return
        self.midTraverse(pRoot.left)
        print(pRoot.value)
        self.midTraverse(pRoot.right)

    # 后序遍历
    # 遍历顺序--> 左子树 -> 右子树 -> 根节点
    def afterTraverse(self, pRoot):
        if pRoot is None:
            return
        self.afterTraverse(pRoot.left)
        self.afterTraverse(pRoot.right)
        print(pRoot.value)

    # 广度优先遍历即是层次遍历，按一层一层地遍历。
    def levelOrder(self, pRoot):
        # 如果根节点为空，则返回空列表
        if pRoot is None:
            return []
        # 模拟一个队列储存节点
        q = []
        # 首先将根节点入队
        q.append(pRoot)
        # 列表为空时，循环终止
        while len(q) != 0:
            length = len(q)
            for i in range(length):
                # 将同层节点依次出队
                r = q.pop(0)
                if r.left is not None:
                    # 非空左孩子入队
                    q.append(r.left)
                if r.right is not None:
                    # 非空右孩子入队
                    q.append(r.right)
                print(r.value)


if __name__ == '__main__':
    # A
    # B  C
    # D  E  F  G

    node1 = TreeNode("A",
                     TreeNode("B",
                              TreeNode("D"),
                              TreeNode("E")
                              ),
                     TreeNode("C",
                              TreeNode("F"),
                              TreeNode("G")
                              )
                     )
    solution = Solution()
    depth = solution.TreeDepth(node1)
    print(depth)
    print('=' * 30)
    solution.preTraverse(node1)
    print('='*30)
    solution.levelOrder(node1)