二叉树的遍历(Python)

二叉树的遍历(Python)

标签（空格分隔）： 二叉树

---

用Python实现二叉树的遍历。
定义树的节点：

class Node():
    def __init__(self, item):
        self.value = item
        self.lchild = None
        self.rchild = None

定义树，初始化树为空，根节点为None。树结构每一个节点均为一个node类型的结构，将其组合成一个树形结构。
使用函数Addnode(self, item)添加节点。

class Tree():
    def __init__(self):
        self.root = None
    def Addnode(self, item):    #添加节点
        pass
    def PreOrderTraverse(self, root)    #前序遍历
        pass
    def InOrderTraverse(self, root)     #中序遍历
        pass
    def PostOrderTraverse(self, root)   #后序遍历
        pass

按照完全二叉树的顺序进行添加节点：

def Addnode(self, item):
    node = Node(item)

    if self.root == None:
        self.root = node

    else:
        q = [self.root]

        while True:
            pop_node = q.pop(0)
            if pop_node.lchild==None:
                pop_node.lchild = node
                return
            elif pop_node.rchild==None:
                pop_node.rchild = node
                return
            else:
                q.append(pop_node.lchild)
                q.append(pop_node.rchild)

首先使用添加的item生成Node节点，每个节点都包含三项value lchild rchild分别作为值，左孩子，右孩子。
如果树的根节点为None，则将node作为根节点root。
否则，根节点暂存入list，循环顺序检查其lchild rchild如果存在空位置，则将node填入。如果当前根节点的左右孩子都存在，则将左右孩子存入list，并查看左孩子的情况，如果满将其左右孩子添加list，并查看当前根节点的右孩子，循环查找，直到找到空位插入node。最终得到完全二叉树。

前序遍历：PreOrderTraverse()

def PreOrderTraverse(self, root):
    '''preorder traverse
    前序遍历
    '''
    if root is None:
        return []
    result = [root.value]
    left_item = self.PreOrderTraverse(root.lchild)
    right_item = self.PreOrderTraverse(root.rchild)
    return result + left_item + right_item

使用递归的方法进行处理，依次处理根节点、左子树、右子树。当树为空时，返回空列表。
从根节点开始对齐左右子树进行递归遍历访问。由于每一层前序遍历可以看为根节点与左右孩子的交互，因此在递归到最底层时返回值的顺序即为遍历的顺序。
前序遍历的顺序为：根-左-右。所以返回值为result + left_item + right_item

中序遍历：InOrderTraverse()。顺序为左-根-右。

def InOrderTraverse(self, root):
    '''inorder traverse
    中序遍历
    '''
    if root is None:
        return []
    result = [root.value]
    left_item = self.InOrderTraverse(root.lchild)
    right_item = self.InOrderTraverse(root.rchild)
    return left_item + result +  right_item

后序遍历：PostOrderTraverse()。顺序为左-右-根。

def PostOrderTraverse(self, root):
    '''postorder traverse
    后序遍历
    '''
    if root is None:
        return []
    result = [root.value]
    left_item = self.PostOrderTraverse(root.lchild)
    right_item = self.PostOrderTraverse(root.rchild)
    return left_item  +  right_item + result

三种遍历方式不同点仅在于递归的返回值，返回值顺序不同得到的遍历结果不同。
原因即在于，递归方法的返回值代表了所做的遍历方法的顺序。