python二叉树的实现

class Node(object):

    def __init__(self, item):
        self._data = item
        self._left = None
        self._right = None

    @property
    def data(self):
        return self._data

    @property
    def left(self):
        return self._left

    @property
    def right(self):
        return self._right

    @data.setter
    def data(self, value):
        self._data = value

    @left.setter
    def left(self, value):
        self._left = value

    @right.setter
    def right(self, value):
        self._right = value


class BTree(object):

    def __init__(self, root=None):
        self.root = root

    def add_node(self, value):
        node = Node(value)
        # 如果树是空的，则对根节点赋值
        if self.root is None:
            self.root = node
            return
        else:
            node_list = []
            node_list.append(self.root)
            # 对已经有的节点进行层次遍历，进行插入操作
            while node_list:

                cur = node_list.pop(0)

                if cur.left is None:
                    cur.left = node
                    return
                elif cur.right is None:
                    cur.right = node
                    return
                else:
                    # 如果左右子树都不为空，加入队列继续判断
                    node_list.append(cur.left)
                    node_list.append(cur.right)

    def get_root(self):
        return self.root

    def pre_order1(self, root):
        """ 先序遍历  递归实现
        若二叉树为空，为空操作；否则（1）访问根节点；（2）先序遍历左子树；（3）先序遍历右子树
        根节点——左子节点——右子节点
        """

        if root is None:
            return
        print(root.data)
        self.pre_order1(root.left)
        self.pre_order1(root.right)

    def pre_oder2(self, root):
        """ 先序遍历  迭代实现
        """
        stack = [root]
        while stack:
            s = stack.pop()
            if s:
                print(s.data)
                stack.append(s.right)
                stack.append(s.left)

    def mid_order1(self, root):
        """ 中序遍历 递归方式
        若二叉树为空，为空操作；否则（1）中序遍历左子树；（2）访问根结点；（3）中序遍历右子树。
        左子节点——根节点——右子节点
        """
        if root is None:
            return

        self.mid_order1(root.left)
        print(root.data)
        self.mid_order1(root.right)

    def mid_order2(self, root):
        """ 中序遍历 迭代方式
        """
        stack = []
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            print(root.data)
            root = root.right

    def pos_order(self, root):
        """ 后序遍历
        """
        if root is None:
            return
        self.pos_order(root.left)
        self.pos_order(root.right)
        print(root.data)

    def bfs(self, root):
        """ 层次遍历
        """
        queue = [root]
        while queue:
            q = queue.pop(0)
            if q:
                print(q.data)
                queue.append(q.left)
                queue.append(q.right)

    def get_depth(self):

        if self.root is None:
            return 0
        else:
            pass


def main():
    btree = BTree()

    for x in range(11):
        btree.add_node(x)

    y = btree.get_root()
    #
    btree.bfs(y)


def test1():
    node1 = Node(2)
    node2 = Node(3)
    list1 = []
    list1.append(node1)
    list1.append(node2)
    print(list1)
    for x in list1:
        print(type(x))
        print(x)


if __name__ == '__main__':
    main()