二叉树遍历

遍历方式

1、NLR：前序(Preorder Traversal 亦称（先序遍历））

 访问根结点的操作发生在遍历其左右子树之前。

2、LNR：中序遍历(Inorder Traversal)

访问根结点的操作发生在遍历其左右子树之中（间）。

3、 LRN：后序遍历(Postorder Traversal)

访问根结点的操作发生在遍历其左右子树之后。

4、层序遍历

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

python代码实现

本次代码采用的树是

先序遍历

采用递归的方式来遍历

# 1、先序
def pre_order(node):
    if node is None:
        return
    # 相当于每次都是访问根节点
    print node
    pre_order(node.left)
    pre_order(node.right)

采用迭代的方式，这时候引入一个栈，引入栈的意义在于最后弹出一个时，就访问其右子树

代码如下

# 利用迭代的方式来遍历树，其主要思想就是申请一个栈
def pre_order_iter(root):
    s = []
    node = root
    while True:
        while node:
            print node
            s.append(node)
            node = node.left
        if not s:
            break
        else:
            node = s.pop().right

中序遍历

# 2、中序
def in_order(node):
    if node is None:
        return
    in_order(node.left)
    print node
    in_order(node.right)

后序遍历

# 3、后序
def post_order(node):
    if node is None:
        return
    post_order(node.left)
    post_order(node.right)
    print node

层序遍历

里面有一个队列，将每一次访问的左子树，有字数依次入队。最后出队的结果就是我们的目标结果。

# 4、层序
def level_order(root):
    q = deque([root])
    while q:
        node = q.popleft()
        print node

        if node.left:
            q.append(node.left)
        if node.right:
            q.append(node.right)

完整代码如下

# coding=utf-8
from collections import deque

class TreeNode(object):
    def __init__(self,data=None,left=None,right=None):
        self.data = data
        self.left = left
        self.right = right

    # 这一步是在每次调用某个结点时，自动调用.data的方法
    def __str__(self):
        return str(self.data)

# 方法一
def create_tree():
    A, B, C, D, E, F, G, H, I = [TreeNode(x) for x in 'ABCDEFGHI']
    A.left, A.right = B, C
    B.right = D
    C.left, C.right = E, F
    E.left = G
    F.left,F.right = H, I
    return A


# 遍历有4种遍历方式
# 1、先序
def pre_order(node):
    if node is None:
        return
    # 相当于每次都是访问根节点
    print node
    pre_order(node.left)
    pre_order(node.right)


# 2、中序
def in_order(node):
    if node is None:
        return
    in_order(node.left)
    print node
    in_order(node.right)

# 3、后序
def post_order(node):
    if node is None:
        return
    post_order(node.left)
    post_order(node.right)
    print node
# 4、层序
def level_order(root):
    q = deque([root])
    while q:
        node = q.popleft()
        print node

        if node.left:
            q.append(node.left)
        if node.right:
            q.append(node.right)



# 利用迭代的方式来遍历树，其主要思想就是申请一个栈
def pre_order_iter(root):
    s = []
    node = root
    while True:
        while node:
            print node
            s.append(node)
            node = node.left
        if not s:
            break
        else:
            node = s.pop().right



if __name__ == "__main__":
    root = create_tree()
    # pre_order(root)
    # in_order(root)
    # post_order(root)
    # pre_order_iter(root)
    level_order(root)