python完成二叉树的基本操作(递归实现)

二叉树结构的基本操作(创建二叉树,先序、中序、后序、层次遍历)递归实现

#创建树的结点类
class TreeNode(object):

    #定义树的结点内容（数据、左右孩子）
    def __init__(self,_telem,_lchild = None,_rchild = None):
        self._telem = _telem
        self._lchild = _lchild
        self._rchild = _rchild

#树的类
class Tree(object):

    #初始化根结点
    def __init__(self,_root = None):
        self._root = _root

    #递归创建二叉树
    def createTree(self,tree_data):

        _elem = input('输入创建树的元素(-1结束):')
        if _elem == '-1':
            return
        #将需要添加的元素实例化为树的结点
        tree_node = TreeNode(tree_data)
        tree_node._telem = _elem
        #递归创建其左孩子、右孩子
        tree_node._lchild = self.createTree(tree_node._lchild)
        tree_node._rchild = self.createTree(tree_node._rchild)
        #将结点对象返回
        return tree_node

    #递归实现先序遍历
    def preorder_traversal(self, _root):

        #判断是否为空
        if _root == None:
            return
        #打印根结点元素数据
        print(_root._telem,end=' ')
        #循环遍历其子树
        self.preorder_traversal(_root._lchild)
        self.preorder_traversal(_root._rchild)

    #递归实现中序遍历
    def inorder_traversal(self,_root):
        #判断空
        if _root == None:
            return
        self.inorder_traversal(_root._lchild)
        print(_root._telem,end=' ')
        self.inorder_traversal(_root._rchild)

    #递归后序遍历
    def postorder_traversal(self,_root):

        #判断空
        if _root == None:
            return
        #调用递归函数
        self.postorder_traversal(_root._lchild)
        self.postorder_traversal(_root._rchild)
        print(_root._telem,end=' ')

    #层次遍历
    def leval_traversal(self,_root):
        #判空
        if _root == None:
            return
        #创建一个判断数组
        queue = []
        queue.append(_root)
        while queue:
            #抛出第一个元素打印其值
            tree_node = queue.pop(0)
            print(tree_node._telem,end=' ')
            #判断是否为空(不为空则将其加入到判断列表中)
            if tree_node._lchild != None:
                queue.append(tree_node._lchild)
            if tree_node._rchild != None:
                queue.append(tree_node._rchild)

    #交换二叉树的左右子树位置
    def interconvert_child(self,_root):
        #判断空
        if _root == None:
            return
        #结束递归条件，左右孩子同时为空的时候结束递归交换
        while (_root._lchild != None or _root._rchild != None):
            # 交换结点
            _root._lchild,_root._rchild = _root._rchild,_root._lchild
            #反转左右结点
            self.interconvert_child(_root._lchild)
            self.interconvert_child(_root._rchild)
            #返回结点
            return _root


if __name__ == '__main__':
    tree = Tree()
    s = tree.createTree('Node')
    print('先序遍历:\n',end=' ')
    tree.preorder_traversal(s)
    print('\n中序遍历:\n', end=' ')
    tree.inorder_traversal(s)
    print('\n后序遍历:\n', end=' ')
    tree.postorder_traversal(s)
    print('\n层次遍历:\n', end=' ')
    tree.leval_traversal(s)

    print('\n\n左右子树交换顺序之后遍历结果:\n\n')
    
    tree.interconvert_child(s)
    print('左右子树交换顺序之后先序遍历:\n', end=' ')
    tree.preorder_traversal(s)
    print('\n左右子树交换顺序之后中序遍历:\n', end=' ')
    tree.inorder_traversal(s)
    print('\n左右子树交换顺序之后后序遍历:\n', end=' ')
    tree.postorder_traversal(s)
    print('\n左右子树交换顺序之后层次遍历:\n', end=' ')
    tree.leval_traversal(s)