二叉树的创建与递归和非递归遍历

二叉树的常规操作就是遍历，这也是二叉树的基本功之一

class TreeNode():
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class BinaryTree(object):
    def __init__(self, pre, tin):
        self.pre = pre
        self.tin = tin
        self.levelTrave = [] # 层次遍历结果
        self.preTraveRecur = [] # 前序递归遍历结果
        self.preTraveNoRecur = [] # 前序非递归遍历结果
        self.inTraveRecur = [] # 中序递归遍历结果
        self.inTraveNoRecur = [] # 中序非递归遍历结果
        self.postTraveRecur = [] # 后序递归遍历结果
        self.postTraveNoRecur = [] # 后序非递归遍历结果

    # 利用前序遍历和中序遍历结果重建二叉树
    def reConstructBinaryTree(self, pre, tin): # pre为前序遍历结果，tin为中序遍历结果
        if len(pre) == 0:
            return None
        if len(pre) == 1:
            return TreeNode(pre[0])
        else:
            res = TreeNode(pre[0])
            res.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0]) + 1], tin[:tin.index(pre[0])])
            res.right = self.reConstructBinaryTree(pre[tin.index(pre[0]) + 1:], tin[tin.index(pre[0]) + 1:])
        return res

    # 层次遍历
    def levelTraversal(self, pRoot):
        aux = []
        if pRoot != None: # 将开始的非空根节点加入到aux列表中
            aux = [pRoot]

        while len(aux): # 判断aux列表中是否还有元素，如果有元素继续访问，否则遍历结束
            p = aux.pop(0) # 模拟队列每次取列表首元素
            self.levelTrave.append(p.val)
            if p.left != None: # 如果当前首元素有左节点将其加入aux列表尾部
                aux.append(p.left)
            if p.right != None: # 如果当前首元素有右节点将其加入aux列表尾部
                aux.append(p.right)

    # 前序递归遍历
    def preorderTraversalRecursion(self, pRoot):
        if pRoot == None:
            return
        self.preTraveRecur.append(pRoot.val) #！！！！！！！
        if pRoot.left != None:
            self.preorderTraversalRecursion(pRoot.left)
        if pRoot.right != None:
            self.preorderTraversalRecursion(pRoot.right)

    # 前序非递归遍历
    def preorderTraversalNoRecursion(self, pRoot):
        if pRoot == None:
            return
        aux = []
        node = pRoot
        while node or aux:
            while node:
                # 从根节点开始，一直找它的左子树
                self.preTraveNoRecur.append(node.val)
                aux.append(node)
                node = node.left
                # while结束表示当前节点node为空，即前一个节点没有左子树了
            node = aux.pop()
            # 开始查看它的右子树
            node = node.right

    # 中序递归遍历
    def inorderTraversalRecursion(self, pRoot):
        if pRoot == None:
            return
        if pRoot.left != None:
            self.inorderTraversalRecursion(pRoot.left)
        self.inTraveRecur.append(pRoot.val) # ！！！！！！！！
        if pRoot.right != None:
            self.inorderTraversalRecursion(pRoot.right)

    # 中序非递归遍历
    def inorderTraversalNoRecursion(self, pRoot):
        if root == None:
            return
        aux = []
        node = root
        while node or aux:
            while node:
                # 　从根节点开始，一直找到左子树
                aux.append(node)
                node = node.left
            # while结束表示当前节点node为空，即前一个节点没有左子树了
            node = aux.pop()
            self.inTraveNoRecur.append(node.val)
            node = node.right

    # 后序递归遍历
    def postorderTraversalRecursion(self, pRoot):
        if pRoot == None:
            return
        if pRoot.left != None:
            self.postorderTraversalRecursion(pRoot.left)
        if pRoot.right != None:
            self.postorderTraversalRecursion(pRoot.right)
        self.postTraveRecur.append(pRoot.val) # ！！！！！！

    # 后序非递归遍历
    def postorderTraversalNoRecursion(self, pRoot):
        if root == None:
            return
        aux = []
        node = root
        while node or aux:
            while node:
                # 从根节点开始，一直找它的右子树
                self.postTraveNoRecur.insert(0, node.val)
                aux.append(node)
                node = node.right
            # while结束表示当前节点node为空，即前一个节点没有右子树了
            node = aux.pop()
            # 开始查看它的左子树
            node = node.left

if __name__ == '__main__':
    # 利用前序与中序遍历重建二叉树
    pre = [1, 2, 4, 7, 3, 5, 6, 8]
    tin = [4, 7, 2, 1, 5, 3, 8, 6]
    BT = BinaryTree(pre, tin)
    root = BT.reConstructBinaryTree(BT.pre, BT.tin)

    # 层次遍历
    BT.levelTraversal(root)
    print("层次遍历结果：", BT.levelTrave)

    # 前序递归遍历
    BT.preorderTraversalRecursion(root)
    print("前序递归遍历：", BT.preTraveRecur)

    # 前序非递归遍历
    BT.preorderTraversalNoRecursion(root)
    print("前序非递归遍历：", BT.preTraveNoRecur)

    # 中序递归遍历
    BT.inorderTraversalRecursion(root)
    print("中序递归遍历：", BT.inTraveRecur)

    # 中序非递归遍历
    BT.inorderTraversalNoRecursion(root)
    print("中序非递归遍历", BT.inTraveNoRecur)

    # 后序递归遍历
    BT.postorderTraversalRecursion(root)
    print("后序递归遍历", BT.postTraveRecur)

    # 后序非递归遍历
    BT.postorderTraversalNoRecursion(root)
    print("后序非递归遍历", BT.postTraveNoRecur)

 

来源：https://www.cnblogs.com/shnuxiaoan/p/12241694.html