数据结构与算法 二叉树

一、树

（ 一）树的介绍

树（英语：tree）是一种抽象数据类型（ADT）或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

• 每个节点有零个或多个子节点；
• 没有父节点的节点称为根节点；
• 每一个非根节点有且只有一个父节点；
• 除了根节点外，每个子节点可以分为多个不相交的子树

（二）树的术语

• 节点的度：一个节点含有的子树的个数称为该节点的度；
• 树的度：一棵树中，最大的节点的度称为树的度；
• 叶节点：度为零的节点；
• 父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
• 子节点：一个节点含有的子树的根节点称为该节点的子节点；
• 兄弟节点：具有相同父节点的节点互称为兄弟节点；
• 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
• 树的高度或深度：树中节点的最大层次；
• 堂兄弟节点：父节点在同一层的节点互为堂兄弟；
• 节点的祖先：从根到该节点所经分支上的所有节点；
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
• 森林：由m（m>=0）棵互不相交的树的集合称为森林；

（三）树的应用场景

• 1.xml，html等，那么编写这些东西的解析器的时候，不可避免用到树
• 2.路由协议就是使用了树的算法
• 3.mysql数据库索引
• 4.文件系统的目录结构
• 5.所以很多经典的AI算法其实都是树搜索，此外机器学习中的decision tree也是树结构

二、二叉树

（一）基本概念

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）

（二）代码创建（注释较为详细，解释了原理，此处不赘述）

#!usr/bin/env python
# -*-coding utf-8 _*-
"""
@author: Herrillero
@file: 二叉树.py
@time:2021/07/27
@desc:
"""


class Node(object):
    """节点类"""

    def __init__(self, elem=-1, lchild=None, rchild=None):
        # 每一个节点都包含一个左孩子和一个右孩子，这是二叉树的特点和灵魂
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild


class Tree(object):
    """树类"""

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

    def add(self, elem):
        """为树增加节点"""
        # 首先创建一个节点
        node = Node(elem)
        # 判断二叉树是否有根节点，若无则此节点作为根节点
        if self.root == None:
            self.root = node
        # 若二叉树已经有根节点，则继续向下寻找位置
        else:
            # 用列表来创建一个队列，用pop和append来保证左出右进
            queue = []
            # 因为根节点存在，将根节点加入队列中
            queue.append(self.root)
            while queue:
                cur = queue.pop(0)
                # 判断节点的左孩子是否为插入位置，若为空则为插入位置 将node赋给左孩子
                if cur.lchild == None:
                    cur.lchild = node
                    return
                # 左节点不为空，判断右节点是否为插入位置
                elif cur.rchild == None:
                    cur.rchild = node
                    return
                # 若该节点的左右孩子都不为插入位置，则该左右节点加入队列，作为下一轮判断的根节点
                else:
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)
        # 二叉树的深度优先遍历
        # 深度优先是自上而言对树进行遍历
        # 1.先序遍历：先序遍历先输出根节点，再输出左孩子，最后为右孩子。当根节点输出后，左孩子又会变成
        # 根节点，用迭代来判断最佳。

    def preorder(self, root):
        """先序遍历"""
        # 迭代退出条件：子树的根节点为空
        if root == None:
            return
        # 打印根节点，再将树分为左树和右树，左右树里又有根节点，用函数迭代输出
        print(root.elem, end=" ")
        # 将根节点的左孩子作为根节点输入
        self.preorder(root.lchild)
        # 将根节点的右孩子作为根节点输入
        self.preorder(root.rchild)

    def inorder(self, root):
        """层序遍历"""
        # 先打印左孩子 再根节点 再右孩子
        if root == None:
            return
        self.inorder(root.lchild)
        print(root.elem, end=" ")
        self.inorder(root.rchild)

    def postorder(self, root):
        """后序遍历"""
        # 先打印左孩子 再右孩子 再根节点
        if root == None:
            return
        # 先处理左孩子
        self.postorder(root.lchild)
        # 再处理右孩子
        self.postorder(root.rchild)
        # 最后处理根
        print(root.elem, end=" ")

    # 广度优先遍历：一层一层的循环二叉树，类似与add函数
    def breadth_travel(self, root):
        """层次遍历"""
        # 迭代退出条件：输入的根节点为空
        if root == None:
            return
        queue = []
        queue.append(root)
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem, end=" ")
            # 如果节点的左孩子不为空，将左孩子加入队列，作为节点进入循环
            if cur_node.lchild != None:
                queue.append(node.lchild)
            # 如果节点的右孩子不为空，将右孩子加入队列，作为节点进入循环
            if cur_node.rchild != None:
                queue.append(node.rchild)


if __name__ == "__main__":
    s = Tree()
    s.add(1)
    s.add(2)
    s.add(3)
    s.add(4)
    s.add(5)
    s.add(6)
    s.add(7)
    print("后序遍历为：")
    s.postorder(s.root)
    print()
    print("层序遍历为：")
    s.breadth_travel(s.root)
    print()
    print("中序遍历为：")
    s.inorder(s.root)
    print()
    print("前序遍历为：")
    s.preorder(s.root)