二叉树相关基础知识总结

Posted 2021-01-30 yeyangsen

一：树的概念

树是一种数据结构，它是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

　　1：每个结点有零个或多个子结点；

　　2：没有父结点的结点称为根结点；

　　3：每一个非根结点有且只有一个父结点；

　　4：除了根结点外，每个子结点可以分为多个不相交的子树

 

 

 

二：树相关术语

节点的度：一个节点含有的子树的个数称为该节点的度；

叶节点或终端节点：度为0的节点称为叶节点；

非终端节点或分支节点：度不为0的节点；

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；

兄弟节点：具有相同父节点的节点互称为兄弟节点；

树的度：一棵树中，最大的节点的度称为树的度；

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度：树中节点的最大层次；

堂兄弟节点：双亲在同一层的节点互为堂兄弟；

节点的祖先：从根到该节点所经分支上的所有节点；

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。

森林：由m（m>=0）棵互不相交的树的集合称为森林；

 

 

三：树的种类

无序树：树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树;

有序树：树中任意节点的子结点之间有顺序关系，这种树称为有序树；

二叉树：每个节点最多含有两个子树的树称为二叉树；

完全二叉树

满二叉树

霍夫曼树：带权路径最短的二叉树称为哈夫曼树或最优二叉树；

 

 

 

四：二叉树

定义：在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。

二叉树的节点表示以及树的构建：

class Node:
    """二叉树节点类"""
    def __init__(self, item):
        self.value = item
        self.lchild = None
        self.rchild = None


class Tree:
    """二叉树"""
    def __init__(self):
        self.root = None

    def add(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

 

 

五：二叉树遍历

一：层次遍历

　　即按照层次访问，通常用队列来做。访问根，访问子女，再访问子女的子女

二：先序遍历

　　我们先访问根节点，然后递归使用先序遍历去访问左子树，再递归使用先序遍历访问右子树   （根节点   左子树    右子树）

三：中序遍历

　　我们递归使用中序遍历去访问左子树，然后访问根节点，再递归使用中序遍历访问右子树   （左子树    根节点      右子树）

四：后序遍历

　　我们递归使用后序遍历去访问左子树，然后递归使用后序遍历访问右子树，再访问根节点   （左子树    右子树     根节点）

代码实现：

class Node:
    """二叉树节点类"""
    def __init__(self, item):
        self.value = item
        self.lchild = None
        self.rchild = None


class Tree:
    """二叉树"""
    def __init__(self):
        self.root = None

    def add(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def level_travel(self):
        """层次遍历，广度优先
            从树的根节点开始 从上到下从左到右遍历整个树的节点
        """
        if self.root is None:
            return
        queue = [self.root]
        print(self.root.value, end=‘ ‘)
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is not None:
                print(cur_node.lchild.value, end=‘ ‘)
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                print(cur_node.rchild.value, end=‘ ‘)
                queue.append(cur_node.rchild)

    def pre_order(self, node):
        """先序遍历"""
        if node is None:
            return
        print(node.value, end=‘ ‘)
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

    def inorder(self, node):
        """中序遍历"""
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.value, end=‘ ‘)
        self.inorder(node.rchild)

    def postorder(self, node):
        """后序遍历"""
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.value, end=‘ ‘)


tree = Tree()
tree.add(0)
tree.add(1)
tree.add(2)
tree.add(3)
tree.add(4)
tree.add(5)
tree.add(6)
tree.add(7)
tree.add(8)
tree.add(9)
tree.breadth_travel()      # 0 1 2 3 4 5 6 7 8 9
print(‘‘)
tree.pre_order(tree.root)   # 0 1 3 7 8 4 9 2 5 6
print(‘‘)
tree.inorder(tree.root)   # 7 3 8 1 9 4 0 5 2 6
print(‘‘)
tree.postorder(tree.root)  # 7 8 3 9 4 1 5 6 2 0

View Code

 

图解：