用递归和非递归方法实现二叉树的前序、中序、后序遍历以及层序遍历

递归方法实现：

class BTree:
    def __init__(self, value):
        self.root = value
        self.left = None
        self.right = None
#前序遍历：中左右
    def preorder(self):
        if self.root:
            print(self.root, end=' ')
        if self.left:
            self.left.preorder()
        if self.right:
            self.right.preorder()
#中序遍历：左中右
    def inorder(self):
        if self.left:
            self.left.inorder()
        if self.root:
            print(self.root, end=" ")
        if self.right:
            self.right.inorder()
#后序遍历：左右中
    def postorder(self):
        if self.left:
            self.left.postorder()
        if self.right:
            self.right.postorder()
        if self.root:
            print(self.root, end=" ")
#层序遍历
    def levelorder(self):
        level_order = []
        if self.root:
            level_order.append([self])
        height = self.height()
        if height >= 1:
            for _ in range(2, height + 1):
                level = []
                for node in level_order[-1]:
                    if node.left:
                        level.append(node.left)
                    if node.right:
                        level.append(node.right)
                if level:
                    level_order.append(level)
        for i in range(0, height):
            for index in range(len(level_order[i])):
                level_order[i][index] = level_order[i][index].root
        return level_order
#设置高度
    def height(self):
        if self.root is None:
            return 0
        elif self.left is None and self.right is None:
            return 1
        elif self.left is None and self.right:
            return 1 + self.right.height()
        elif self.left and self.right is None:
            return 1 + self.left.height()
        else:
            return 1 + max(self.left.height(), self.right.height())
#对树的叶子进行遍历
    def leaves(self):
        if self.root is None:
            return
        elif self.left is None and self.right is None:
            print(self.root, end=' ')
        elif self.left is None and self.right:
            self.right.leaves()
        elif self.right is None and self.left:
            self.left.leaves()
        else:
            self.left.leaves()
            self.right.leaves()

非递归方法实现：

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

#前序遍历：根左右
class Solution:
    def preordder(self,root):
        temp=[root]
        dp=[]
        while temp:
            tmp=temp.pop()
            dp.append(tmp.val)
            if tmp.right:
                temp.append(tmp.right)
            if tmp.left:
                temp.append(tmp.left)
        return dp
#中序遍历：左根右：
'''先定义两个空列表，
设置变量存储根节点，再对定义的空列表和当前变量进行遍历，将第一个空列表用来存储根节点，然后返回到左节点，定义变量=第一个列表删除的元素
第二个元素用来存储当前的删除的节点值，设置变量将其传给当前根节点的右孩子，最后返回遍历的数据列表
'''
class Solution1:
    def middleorder(self,root):
        stack=[]
        res=[]
        r=root
        while stack or r:
            if r:
                stack.append(r)
                r=r.left
            else:
                node=stack.pop()
                res.append(node.val)
                r=node.right
        return res
#后序遍历：左右根：
'''
先设置两个空数组用于后续读取和设置遍历的节点，
先将根节点传给其中一个数组进行存储
设置一个循环，其中设置变量等于根节点中弹出的一个元素，
并在另一个空数组中添加当前弹出元素的节点
后走到左孩子，将根节点树的左孩子传给第一个数组，并且添加进去
随后看右孩子，再将右孩子添加到第一个数组
最后将该结果返回到第二个空数组即可
'''
class Solution2:
    def backorder(self,root):
        dp1=[root]
        dp2=[]
        while dp1:
            cur=dp1.pop()
            dp2.append(cur.val)
            if cur.left:
                dp1.append(cur.left)
            if cur.right:
                dp1.append(cur.right)
        return dp2[-1]
#层序遍历：对每层元素开始遍历
'''
先设置空的数组，将根节点添加一个数组中方便后续遍历
设置while循环对每层进行遍历，将每层的节点元素弹出后存入一个空的数组，
最后将每层的元素进行遍历和存储
'''
class Solution3:
    def levelbianli(self,root):
        outlist1=[]
        outlist2=[]
        outlist1.append(root)
        while outlist1:
            res=[]
            i=0
            temp=outlist1.pop(0)
            res.append(temp.val)
            nums=len(outlist1)
            while i<nums:
                p=outlist1.pop(0)
                res.append(p.val)
                if p.left:
                    outlist1.append(p.left)
                if p.right:
                    outlist1.append(p.right)
                i+=1
            outlist2.append(res)
        return outlist2