二叉树遍历中的递归解析（python）

目录

一.前序遍历

二.中序遍历

三.后序遍历

---

测试使用的二叉树如下：

a

b

c

d

e

f

g

h

i

j

k

l

m

n

NULL

一.前序遍历

前序遍历的顺序如下：

a,1

b,2

c,9

d,3

e,6

f,10

g,13

h,4

i,5

j,7

k,8

l,11

m,12

n,14

NULL

前序遍历代码：

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def traversal(self, root):
        def backtrack(root):
            if not root:
                return
            else:
                res.append(root.val) # 入栈时执行
                # 第一个backtrack入栈
                backtrack(root.left) # 出栈时执行
                # 第一个backtrack出栈
                # 第二个backtrack入栈
                backtrack(root.right) # 出栈时执行
                # 第二个backtrack出栈

        res = []
        backtrack(root)
        return res

root = TreeNode('a',TreeNode('b',TreeNode('d',TreeNode('h',None,None),TreeNode('i',None,None)),TreeNode('e',TreeNode('j',None,None),TreeNode('k',None,None))),TreeNode('c',TreeNode('f',TreeNode('l',None,None),TreeNode('m',None,None)),TreeNode('g',TreeNode('n',None,None),None)))
print(Solution().traversal(root))


# ['a', 'b', 'd', 'h', 'i', 'e', 'j', 'k', 'c', 'f', 'l', 'm', 'g', 'n']

1.递归是栈，先入后出，递归函数前的代码是入栈时执行，递归函数的代码是出栈时执行，递归函数后的代码是出栈时执行；

2.第一个backtrack先全部入栈（left节点遍历）后，第一个backtrack再依次出栈，出栈的同时第二个backtrack依次入栈（right节点遍历），第二个backtrack的出入栈也遵循上述顺序。

3.可以看到，前序遍历的顺序正是初始化生成root数据的顺序（不包括None），也是leetcode里测试用例输入的顺序（不包括None）。

二.中序遍历

中序遍历的顺序如下：

a,8

b,4

c,12

d,2

e,6

f,10

g,14

h,1

i,3

j,5

k,7

l,9

m,11

n,13

NULL

中序遍历代码：

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def traversal(self, root):
        def backtrack(root):
            if not root:
                return
            else:
                # 第一个backtrack入栈
                backtrack(root.left) # 出栈时执行
                # 第一个backtrack出栈
                res.append(root.val) # 出栈时执行
                # 第二个backtrack入栈
                backtrack(root.right) # 出栈时执行
                # 第二个backtrack出栈

        res = []
        backtrack(root)
        return res

root = TreeNode('a',TreeNode('b',TreeNode('d',TreeNode('h',None,None),TreeNode('i',None,None)),TreeNode('e',TreeNode('j',None,None),TreeNode('k',None,None))),TreeNode('c',TreeNode('f',TreeNode('l',None,None),TreeNode('m',None,None)),TreeNode('g',TreeNode('n',None,None),None)))
print(Solution().traversal(root))


# ['h', 'd', 'i', 'b', 'j', 'e', 'k', 'a', 'l', 'f', 'm', 'c', 'n', 'g']

三.后序遍历

后序遍历的顺序如下：

a,14

b,7

c,13

d,3

e,6

f,10

g,12

h,1

i,2

j,4

k,5

l,8

m,9

n,11

NULL

后序遍历代码：

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def traversal(self, root):
        def backtrack(root):
            if not root:
                return
            else:
                # 第一个backtrack入栈
                backtrack(root.left) # 出栈时执行
                # 第一个backtrack出栈
                # 第二个backtrack入栈
                backtrack(root.right) # 出栈时执行
                # 第二个backtrack出栈
                res.append(root.val) # 出栈时执行

        res = []
        backtrack(root)
        return res

root = TreeNode('a',TreeNode('b',TreeNode('d',TreeNode('h',None,None),TreeNode('i',None,None)),TreeNode('e',TreeNode('j',None,None),TreeNode('k',None,None))),TreeNode('c',TreeNode('f',TreeNode('l',None,None),TreeNode('m',None,None)),TreeNode('g',TreeNode('n',None,None),None)))
print(Solution().traversal(root))


# ['h', 'i', 'd', 'j', 'k', 'e', 'b', 'l', 'm', 'f', 'n', 'g', 'c', 'a']