树

树的概念

数的性质：

1. 在二叉树的第n层上至多有节点
   $$
   2 ^ {n-1}
   $$

2. 深度未k的数至多有节点
   $$
   2^n-1
   $$

3. 对于任意一颗二叉树，若终端节点数为n， 而度数为2的节点数为 N ,有 n = N + 1

4. 具有n个节点的完全二叉树的深度为
   $$
   log_2n +1
   $$

访问方式：

广度优先-> 层次遍历

深度优先：

​ 先序遍历： 根 左 右

​ 中序遍历： 左 根 右

​ 后序遍历： 左 右 根

树结构实现：

1. 节点介绍：

   1. 根据树的结构来看， 节点需要一个来存储树数据，一个来存储左孩子， 一个来存储有孩子。
   2. 树结构首先需要指明一个根
   3. 添加方法， 我们首先要遍历树，目的是构建完全二叉树， 采用广度优先的方式遍历， 找到空的地方插进去，逻辑如下
      

广度优先是一层一层找。

1. [1]
2. 找到根节点的左右两个孩子， 放到队列中 [2, 3]
3. 找2的左右两个孩子放到队列中[3, 4, 5]
4. 找到3的左右两个孩子放到队列中[4,5,6,7]
5. 找4的左右两个还子找到左孩子放到队列中[5,6,7,8]
6. 右孩子没找到，将新的节点添加进去，结束。

深度优先一个方向找到底

class Node:
    def __init__(self, data):
        """
            根据数的概念： 由 根结点 和左右两个子结点组成,
            data: 数据
            lchild: 左孩子
            rchild: 右孩子
        """
        self.data = data
        self.lchild = ""
        self.rchild = ""


# 树的结构
class Tree:
    def __init__(self):
        """ 
        根节点 

        """
        self.root = None

    def add(self, data):
        node = Node(data)
        queue = [self.root]

        # 如果根节点就是空的则添加进去
        print(data, end=" ")
        if not self.root:
            self.root = node
            return 
        # 队列不为空说明没找完
        while queue:
            cur_node = queue.pop(0)
            # 左节点不为空, 添加到队列
            if cur_node.lchild:
                queue.append(cur_node.lchild)
            else: # 为空插入到树里
                cur_node.lchild = node
                return 

            # 右节点不为空添加进去
            if cur_node.rchild:
                queue.append(cur_node.rchild)
            else: # 为空插入到树里
                cur_node.rchild = node
                return 

    def breadth_order(self):
        """ 广度优先 """
        queue = [self.root]
        if not self.root:
            print("空的")
            return 
        # 队列不为空说明没找完
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.data, end=" ")
            # 左节点不为空, 添加到队列
            if cur_node.lchild:
                queue.append(cur_node.lchild)
            # 右节点不为空添加进去
            if cur_node.rchild:
                queue.append(cur_node.rchild)

    def pre_order(self, node):
        """ 先序遍历 """
        if not node:
            return
        print(node.data, end=" ")
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

    def in_order(self, node):
        """ 中序遍历 """
        if not node:
            return
        self.in_order(node.lchild)
        print(node.data, end=" ")
        self.in_order(node.rchild)

    def end_order(self, node):
        """ 后序遍历 """
        if not node:
            return
        self.end_order(node.lchild)
        
        self.end_order(node.rchild)
        print(node.data, end=" ")


if __name__ == "__main__":
    tree = Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    print("
广度优先")
    # 
    tree.breadth_order()
    print("
先序遍历")
    tree.pre_order(tree.root)
    print("
中续遍历")
    tree.in_order(tree.root)
    print("
后续遍历")
    tree.end_order(tree.root)