树

树是由根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。

相关概念

• 根节点：树中最顶部的元素
• 父节点：处了根节点都有父节点，每个节点最多只有一个父节点
• 孩子节点：一个父节点具有0个或多个孩子节点
• 兄弟节点：同一个父节点的孩子节点之间是兄弟关系
• 外部节点：一个没有孩子的节点称为外部节点，也叫叶子结点
• 内部节点：有一个或多个孩子节点的节点叫做内部节点
• 树的边：指一对节点(u,v)，其中u是v的父节点或者v是u的父节点
• 树的路径：一系列连续的边组成了一条路径
• 节点的深度：节点的深度就是该节点的祖先的个数，不包括该节点本身，如果根节点的层数为1，则深度即为该节点的层数-1
• 节点的高度：如果p是树中的叶子节点，那么它的高度为0.否则p的高度是它的孩子节点中的最大高度+1
• 有序树：每个孩子之间有一定的顺序，例如：

一个树的抽象基类

class Tree():
    """
    树的抽象基类
    """

    # 叫做位置的内嵌类，用于封装节点
    class Position():

        def element(self):
            raise NotImplementedError(‘must be implemented by subclass‘)

        def __eq__(self, other):
            raise NotImplementedError(‘must be implemented by subclass‘)

    def root(self):
        """
        return 根节点的position
        """
        raise NotImplementedError(‘must be implemented by subclass‘)

    def parent(self,p):
        """

        :param p:一个位置对象
        :return: 返回p的父节点的position对象，如果p是根节点则饭后空
        """
        raise NotImplementedError(‘must be implemented by subclass‘)

    def num_children(self,p):
        """

        :param p:一个位置对象
        :return: 返回该位置的孩子节点的数量
        """
        raise NotImplementedError(‘must be implemented by subclass‘)

    def children(self,p):
        """

        :param p: 一个位置对象
        :return: 返回位置p的孩子的迭代
        """
        raise NotImplementedError(‘must be implemented by subclass‘)

    def __len__(self):
        """

        :return: 返回整个树的节点个数
        """

　　　　　raise NotImplementedError(‘must be implemented by subclass‘)

    def is_root(self,p):
        return self.root() == p

    def is_leaf(self,p):
        return self.num_children(p) == 0

    def is_empty(self):
        return len(self) == 0

这个抽象类中的方法必须在子类中实现才能调用，不然会产生NotImplementedError(‘must be implemented by subclass’)的异常

除此之外，对于Position()这个内嵌类可能较难理解，为什么要有这么一个内嵌类

这个内嵌类目前也是抽象类，具体方法都没有实现，但使用它的目的已经有了，就是将树中的节点进行封装，那为什么要封装节点呢？当调用树的相关方法时，节点可能为一个必要的参数，但我们手动传入时，实际上可以是任意的对象，这就会导致错误发生，所以我们必须保证传入的节点是节点的对象，同时也是本树对象的节点，不然就会弄混树与树的节点。同时将节点进行封装，可以避免使用者直接使用节点对象本身，相关节点的方法可以在封装成的Position对象调用。目前只是抽象类的定义，节点类等其他方法还未定义，后面还会看到具体的position对象的使用。

目前有了Tree这个抽象类，虽然其中的大多数方法还是抽象方法，但使用这些方法已经可以构成一些其他的功能了，所以就有了is_root，is_leaf，is_empty方法的定义。同时还可以定义计算节点的深度与高度的方法：

def depth(self,p):
    """
    计算节点在树中的深度
    """
    if self.is_root(p):
        return 0
    else:
        return 1 + self.depth(self.parent(p))

def height(self,p):
    """
    计算节点在树中的深度
    """
    if self.is_leaf(p):
        return 0
    else:
        return 1 + max(self.height(c) for c in self.children(p))

二叉树

我们现在介绍一种树的特殊化形式二叉树

二叉树的特点：

• 每个父节点最多只有两个孩子节点
• 两个孩子节点又叫做左孩子和右孩子
• 以左孩子为根节点形成的树叫做左子树，以右孩子为根节点形成的树叫做右子树
• 如果每个非叶子节点都有两个孩子，那么这个树就叫做完全二叉树
• 非空完全二叉树中，外部节点数=内部节点数+1

二叉树的实现可以以继承树的抽象类的方式实现：

class BinaryTree(Tree):

    class Node():

        def __init__(self, element, parent=None, left=None, right=None):
            self.element = element
            self.parent = parent
            self.left = left
            self.right = right

    class Position(Tree.Position):

        def __init__(self, container, node):
            self.container = container
            self.node = node

        def element(self):
            return self.node.element

        def __eq__(self, other):
            return isinstance(other, type(self)) and other.node is self.node

    def validate(self, p):
        """
        进行位置验证
        """
        if not isinstance(p, self.Position):
            raise TypeError(‘p must be proper Position type‘)
        if p.container is not self:
            raise ValueError(‘p does not belong to this container‘)
        if p.node.parent is p.node:
            raise ValueError(‘p is no longer valid‘)
        return p.node

    def make_position(self, node):
        """
        封装节点
        """
        return self.Position(self, node) if node is not None else None

    def __init__(self):
        self.root = None
        self.size = 0

    def __len__(self):
        return self.size

    def root(self):
        return self.make_position(self.root)

    def parent(self, p):
        node = self.validate(p)
        return self.make_position(node.parent)

    def left(self, p):
        node = self.validate(p)
        return self.make_position(node.left)

    def right(self, p):
        node = self.validate(p)
        return self.make_position(node.right)

    def sibling(self, p):
        parent = self.parent(p)
        if parent is None:
            return None
        else:
            if p == self.left(parent):
                return self.right(parent)
            else:
                return self.left(parent)

    def num_children(self, p):
        node = self.validate(p)
        count = 0
        if node.left is not None:
            count += 1
        if node.right is not None:
            count += 1
        return count
　　

    def children(self,p):
        if self.left(p) is not None:
            yield self.left(p)
        if self.right(p) is not None:
            yield self.right(p)

代码中将之前的抽象方法进行了完整的定义，同时添加了validate与make_position方法。validate方法用于对传入的position参数进行验证，make_position方法用于将节点进行封装。除此之外还添加了二叉树特有的方法right，left和sibling，left与right分别返回节点的左孩子节点与右孩子节点，sibling返回的是节点的兄弟节点。

目前的二叉树的数据结构只是创建了一颗空树，我们接下来要加入的是对二叉树进行更新操作的方法

def add_root(self, e):
    if self.root is not None:
        raise ValueError(‘Root exists‘)
    self.size += 1
    self.root = self.Node(e)
    return self.make_position(self.root)

def add_left(self, e, p):
    node = self.validate(p)
    if node.left is not None:
        raise ValueError(‘Left child exists‘)
    self.size += 1
    node.left = self.Node(e, node)
    return self.make_position(node.left)

def add_right(self, e, p):
    node = self.validate(p)
    if node.right is not None:
        raise ValueError(‘Left child exists‘)
    self.size += 1
    node.right = self.Node(e, node)
    return self.make_position(node.right)

def replace(self, p, e):
    node = self.validate(p)
    old = node.element
    node.element = e
    return old

def delete(self, p):
    """
    删除该位置的节点，如果该节点有两个孩子，则会产生异常，如果只有一个孩子，
    则使其孩子代替该节点与其双亲节点连接
    """
    node = self.validate(p)
    if self.num_children(p) == 2:
        raise ValueError(‘p has two children‘)
    child = node.left if node.left else node.right
    if child is not None:
        child.parent = node.parent
    if node is self.root:
        self.root = child
    else:
        parent = node.parent
        if node is parent.left:
            parent.left = child
        else:
            parent.right = child
    self.size -= 1
    node.parent = node
    return node.element

总共加入了添加根节点，添加左孩子，添加右孩子，代替元素和删除节点5个方法，其中删除几点稍微有一些复杂，因为涉及到许多情况的判断。

到现在，一个完整的二叉树数据结构基本完成了。

但是我们还需要掌握一个算法，就是树的遍历算法

树的遍历

树的遍历一般有先序遍历，后序遍历，广度优先遍历（层序遍历），对于二叉树还有中序遍历

先序遍历

先序遍历是按照根节点->从左到右的孩子节点的顺序遍历，而且把每个孩子节点看作是子树的根节点同样如此，例如：

用python实现先序遍历为：

def preorder(self,p):
    """
    先序遍历节点p为根节点的树
    """
    yield p
    for c in self.children(p):
        for other in self.preorder(c):
            yield other

虽然代码只有4行，但理解起来却不是很容易的，首先该方法是一个生成器，所以通过yield返回一个可迭代对象，也就是可以for循环该方法，由于是先序遍历，所以要先yield p，之后便要返回孩子节点，由于孩子节点可能还具有孩子，所以并不能只返回孩子节点，应该返回以孩子节点为根节点的树的所有节点，而要想for循环得到左右的孩子节点为根节点的所有节点，还需要调用孩子节点的先序遍历方法才能得到。总而言之，代码理解的难度还是由于递归算法造成的，一个复杂的递归终归还是不是那么容易就能看出来的。

后序遍历

后序遍历是按照先从左到右孩子节点->根节点，如图：

用python实现：

def postorder(self,p):
    """
    后序遍历节点p为根的树
    """
    for c in self.children(p):
        for other in self.postorder(c):
            yield other
    yield p

理解与先序遍历相同

广度优先遍历

广度优先遍历也叫层序遍历，一层一层的遍历，如图：

用python实现：

def breadthfirst(self):
    if not self.is_empty():
        queue = Queue()
        queue.enqueue(self.root())
        while not queue.is_empty():
            p = queue.dequeue()
            yield p
            for i in self.children(p):
                queue.enqueue(i)

中序遍历二叉树

对于二叉树，遍历顺序为左孩子->父节点->右孩子

python实现为：

def inorder(self,p):
    if self.left(p) is not None:
        for other in self.inorder(self.left(p)):
            yield other
    if self.right(p) is not None:
        for other in self.inorder(self.right(p)):
            yield other

?

原文地址：https://www.cnblogs.com/sfencs-hcy/p/10341449.html