前序遍历 中序遍历 后续遍历 的真正理解

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁，而对于广度遍历来说，需要其他数据结构的支撑，比如堆了。所以，对于一段代码来说，可读性有时候要比代码本身的效率要重要的多。
 

 

（1）前序遍历

      a、访问根节点；b、前序遍历左子树；c、前序遍历右子树。

（2）中序遍历

      a、中序遍历左子树；b、访问根节点；c、中序遍历右子树。

（3）后序遍历

      a、后序遍历左子树；b、后续遍历右子树；c、访问根节点。

 

到这里你还没理解，一定要注意任何 左 中 右 遍历一定要走到最深处判断他是不是有形成子树，再对其按照规律遍历，后附前序，中序，后序遍历（统称深度遍历）以及层次遍历的代码

        

以中序遍历为例：左-->根--->右：

第一：先看1的左是2，但是我们不能就取2，要再看2的左是4，4没有左了 ，所以第一个取 ：          4

第二：4的根是2 ，所以第二个取：   2

第三：右是5，我们不能取5，因为以5开头右边又是一颗新的树，重新按照 左-->根--->右,  左边取：     7

第四：7的父母节点是5，取：      5

第五：5的有节点是8， 取：    8

第六：返回发现根节点是 1，  取：    1

第七：看最上面根节点的右边第一个节点是3， 考虑3的左节点，发现没有，那么3就是根节点  取：       3

第八：看3的右边是6，取：       6

所以中序遍历顺序为：42758136

 

 

class Node:  #构建树
2     def __init__(self,value=None,left=None,right=None):  
3         self.value=value  
4         self.left=left    #左子树
5         self.right=right  #右子树

#前序遍历
#vals = []
def pre_order(self,root):
    if root == None:
        return 
    print(root.val)
    #vals.append(currentNode.val)
    self.pre_order(root.left)
    self.pre_order(root.right)

#中序遍历 二叉查找树升序输出（中序遍历）
def in_order(self，root):
    if root == None:
        return 
    
    self.in_order(root.left)
    #vals.append(currentNode.val)
    print(root.val)
    self.in_order(root.right)

#后续遍历
def bac_order(self,root):
    if root == None:
        return 
    self.bac_order(root.left)
    self.bac_order(root.right)
    print(root.val)
    #vals.append(currentNode.val)

#层次遍历
def PrintFromTopToBottom(self, root):
    if not root:
        return []
    queue = []
    result = []
    queue.append(root) 
    
    while len(queue)>0:
        node = queue.pop(0)
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result
    
 #层次遍历的详细版，能计算出每层的值，以及层数

class Solution:
    # 层次遍历
    def levelOrder(self, root):
        # write your code here
        # 存储最后层次遍历的结果
        res = []
        # 层数
        count = 0
        # 如果根节点为空，则返回空列表
        if root is None:
            return count
        # 模拟一个队列储存节点
        q = []
        # 首先将根节点入队
        q.append(root)
        # 列表为空时，循环终止
        while len(q) != 0:
            # 使用列表存储同层节点
            tmp = []
            # 记录同层节点的个数
            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)
                tmp.append(r.val)
            if tmp:
                count += 1  # 统计层数
            res.append(tmp)
        return count