leetcode－二叉树的前、中、后序遍历python实现

二叉树是每个节点最多有两个子树的树结构。二叉树的遍历有深度优先遍历(Depth-First-Search，DFS)和广度优先遍历(Breadth-First-Search，BFS)两类。深度优先遍历包括前序遍历、中序遍历、后续遍历；广度优先遍历也就是二叉树层序遍历。访问节点的顺序如下。

前序遍历：根节点，左子节点，右子节点

中序遍历：左子节点，根节点，右子节点

后序遍历：左子节点，右子节点，根节点

层序遍历：从上到下，从左至右依次遍历节点

以下将分别通过递归法和迭代法给出这几种遍历的python实现，分别对应leetcode的以下题目。其中层序遍历的python实现可查找下一篇博客。

二叉树节点类的定义

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

例：二叉树的结构

      1
   /  　\
  2  　 3
 /  \  　/  \
14  5 　6  10

前序遍历为[1, 2, 14, 5, 3, 6, 10]

中序遍历为[14, 2, 5, 1, 6, 3, 10]

后序遍历为[14, 5, 2, 6, 10, 3, 1]

(一). leetcode(144)二叉树的前序遍历

１．递归法

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return  []
        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)
        return [root.val] + left + right

２．迭代法

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return  []
        stack = [root]
        list = []
        while  stack :
            # print('stack',[i.val for i in stack])
            rootn = stack.pop() #出栈
            list.append(rootn.val)
            # print('list',list)
            if rootn.right:
                stack.append(rootn.right)
            if rootn.left:
                stack.append(rootn.left)                
        return list

测试

if __name__ == "__main__":
    nodelist=[TreeNode(i)for i in [1,2,3,14,5,6,10]]
    nodelist[0].left=nodelist[1]
    nodelist[0].right=nodelist[2]
    nodelist[1].left=nodelist[3]
    nodelist[1].right=nodelist[4]
    nodelist[2].left=nodelist[5]
    nodelist[2].right=nodelist[6]

    Tree=nodelist[0]    
    s=Solution()
    m=s.preorderTraversal(Tree)
    print("二叉树的前序遍历为%s"%(m))
#result:
二叉树的前序遍历为[1, 2, 14, 5, 3, 6, 10]

(二). leetcode(94)二叉树的中序遍历 

１．递归法

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return  []
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)
        return  left + [root.val] + right

２．迭代法

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        list = []
        while root or stack:
#             print('stack',[i.val for i in stack])
#             print('list',list)
            while root:
                stack.append(root)
                root = root.left   #非递归过程即:先访问最左子树结点，再访问其父节点，再访问其兄弟
            root = stack.pop()
            list.append(root.val)
            root = root.right
        return list

测试

if __name__ == "__main__":
    nodelist=[TreeNode(i)for i in [1,2,3,14,5,6,10]]
    nodelist[0].left=nodelist[1]
    nodelist[0].right=nodelist[2]
    nodelist[1].left=nodelist[3]
    nodelist[1].right=nodelist[4]
    nodelist[2].left=nodelist[5]
    nodelist[2].right=nodelist[6]

    Tree=nodelist[0]    
    s=Solution()
    m=s.inorderTraversal(Tree)
    print("二叉树的中序遍历为%s"%(m))
#result:
二叉树的中序遍历为[14, 2, 5, 1, 6, 3, 10]

(三). leetcode(145)二叉树的后序遍历

１．递归法

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return  []
        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)
        return  left  + right +[root.val]

２．迭代法

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root == None:
            return  []
        stack = [root]
        list = []
        while  stack :
            rootn = stack.pop() #出栈
            list.append(rootn.val)
            if rootn.left:
                stack.append(rootn.left)     
            if rootn.right:
                stack.append(rootn.right)
        return list[::-1]

测试

if __name__ == "__main__":
    nodelist=[TreeNode(i)for i in [1,2,3,14,5,6,10]]
    nodelist[0].left=nodelist[1]
    nodelist[0].right=nodelist[2]
    nodelist[1].left=nodelist[3]
    nodelist[1].right=nodelist[4]
    nodelist[2].left=nodelist[5]
    nodelist[2].right=nodelist[6]

    Tree=nodelist[0]   
    s=Solution()
    m=s.postorderTraversal(Tree)
    print("二叉树的后序遍历为%s"%(m))
#result:
二叉树的后序遍历为[14, 5, 2, 6, 10, 3, 1]

欢迎关注公众号：算法学习总结，获取更多知识，共同交流学习