【菜鸡新手 - 牛客网刷题NC45 & 剑指offer07】根据 前序遍历 & 中序遍历 重建二叉树 || 二叉树 前、中、后 、层序 遍历 的【递归 】& 【迭代】 || python

以下为原创代码，可以参考，但禁止转载！
@ author：yhr

根据 前序遍历序列 & 中序遍历序列 生成二叉树

#coding=utf-8
#__author__='YHR'
import copy

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



def findNumIndex( L, key):
    # 找到L列表中，key的 index
    length = len(L)
    for _ in range(length):
        if L[_] == key:
            return _
    return -1


def reConstructBinaryTree(pre, tin):
    if len(pre) < 1 or len(tin) < 1:
        return None
    else:
        pre = copy.deepcopy(pre);
        tin = copy.deepcopy(tin)

        headval = pre[0]
        # get 左子树的tin:tinLeft and 右子树的tin：tinRight
        tinHeadIndex =  findNumIndex(tin, headval)  # 找到父节点的 index

        if tinHeadIndex > 0:
            tinLeftTree = tin[0:tinHeadIndex]
        else:
            tinLeftTree = []
        if tinHeadIndex < len(tin) - 1:
            tinRightTree = tin[tinHeadIndex + 1:]
        else:
            tinRightTree = []

        # get 左子树的pre:preleft and 右子树的pre:preRight
        if len(tinLeftTree) >= 1:
            preLeftTree = pre[1:1 + len(tinLeftTree)]
        else:
            preLeftTree = []
        if len(tinRightTree) >= 1:
            preRightTree = pre[1 + len(tinLeftTree):]
        else:
            preRightTree = []

        parentNode = TreeNode(x=headval)
        # left child tree
        parentNode.left = reConstructBinaryTree(preLeftTree, tinLeftTree)
        # right child tree
        parentNode.right = reConstructBinaryTree(preRightTree, tinRightTree)

        return parentNode
 

递归 ： 三种遍历

#coding=utf-8
#__author__='YHR'


class Solution:
    def threeOrders(self, root):
        # write code here
        pass

    def digui_pre_order(self, root):
        # 头 左右
        preorder = []
        if root is not None:
            preorder += [root.val]
            preorder += (self.digui_pre_order(root.left))
            preorder += (self.digui_pre_order(root.right))
        else:
            pass
        return preorder

    def digui_mid_order(self, root):
        # 左 头 右
        midorder = []
        if root is not None:
            midorder += self.digui_mid_order(root.left)
            midorder += [root.val]
            midorder += self.digui_mid_order(root.right)
        else:
            pass
        return midorder

    def digui_post_order(self, root):
        # 左 右 头
        postorder = []
        if root is not None:
            postorder += self.digui_post_order(root.left)
            postorder += self.digui_post_order(root.right)
            postorder += [root.val]
        else:
            pass
        return postorder

迭代 ： 三种遍历

	#coding=utf-8
	#__author__='YHR'

    #     ---------------------- no digui ---------------------

    def nodigui_pre_order(self, root):
        # 头 左右
        stack=[]
        pre_order = []
        if root is None:
            return pre_order
        else:
            stack.insert(0, root)

            while len(stack) > 0:
                node = stack.pop(0)
                pre_order.append(node.val)

                if node.right is not None:
                    stack.insert(0, node.right)
                if node.left is not None:
                    stack.insert(0, node.left)

            return pre_order

    # 不需要递归
    def nodigui_mid_order(self, root):
        #  左 头 右
        stack = []
        mid_order = []
        if root is None:
            return mid_order
        else:
            top = root
            stack.insert(0, top)
            while len(stack) > 0 :
                while top.left is not None:
                    stack.insert(0, top.left)
                    top = top.left
                while len(stack)>0:
                    # while 直到出现 右孩子,或者出栈完毕为止,不走回头路即不走已经遍历过的左孩子
                    #  不加while的话，top弹出以后  如果此时是非叶子节点， 他没有right节点，存在左孩子
                    # 他就会继续压入他的左孩子。但是他的左孩子已经被压进去过了，就会循环
                    top = stack.pop(0)
                    mid_order.append(top.val)
                    if top.right is not None:
                        stack.insert(0, top.right)
                        top = top.right
                        break

            return mid_order

    def nodigui_post_order(self, root):
        #  左 右 头
        stack = []
        post_order = []
        if root is None:
            return post_order
        else:
            top = [root, 1]
            # top[1] 为遍历到top[0]的次数 count, 第一次遍历到它, count=1,入栈,遍历左孩子
            # 第二次遍历到它, count=2  入栈,遍历右孩子
            # count=2 时,再次遍历到他,表示第3次遍历到它, 终于可以真正出栈啦~~~

            stack.insert(0, top)

            while len(stack) > 0:
                while top[0].left is not None:
                    new = [top[0].left, 1]
                    stack.insert(0, new)
                    top = new
                while len(stack) > 0:
                    top = stack.pop(0)
                    if top[1] == 2:
                        post_order.append(top[0].val)
                    else:
                        top = [top[0], 2]
                        stack.insert(0, top)
                        if top[0].right is not None:
                            new = [top[0].right, 1]
                            stack.insert(0, new)
                            top = new
                            break
            return post_order

层序遍历

def cengxuTraverse(root):
	# 层序遍历
    if root is None:
        return []
    else:
        queue = []
        cengxu = []

        queue.append(root)
        while len(queue) > 0:
            node = queue.pop(0)  # 弹出队首元素
            cengxu.append(node.val)
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)
        return cengxu

调用示例

#coding=utf-8
#__author__='YHR'
if __name__=='__main__':
    pre, tin = [44,18,22,40,34,36,31,1,41,30,19,27,16,32,9,3,12,39,20,4,11,10,38,7,23,8,42,35,28,2,14,6,24,15,43,5,33,26,21,17,29,13,25,37],\
               [40,31,36,34,22,18,30,19,41,32,16,27,1,3,12,9,4,20,39,11,44,23,42,8,7,35,28,38,10,15,24,43,26,33,5,6,14,2,29,17,13,21,25,37]

    root = reConstructBinaryTree(pre, tin)  #根据pre and tin 生成二叉树
 	print(cengxuTraverse(root))


    s = Solution()

    print(s.nodigui_pre_order(root))
    print(s.nodigui_mid_order(root))
    print(s.nodigui_post_order(root))