数据结构---树（待补充）

基本概念

1. 相关定义

树是由n（n>0）个有限节点组成一个具有层次关系的集合。
每个节点有零个或多个子节点。
没有父节点的节点称为根节点。
每一个非根节点有且只有一个父节点。
除了根节点外，每个子节点可以分为多个不相交的子树。
节点的度：一个节点含有的子树的个数称为该节点的度。
树的度：一棵树中，最大的节点的度称为树的度。
叶节点或终端节点：度为零的节点。
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推。
深度：对于任意节点n,n的深度为从根到n的唯一路径长，根的深度为0。
高度：对于任意节点n,n的高度为从n到一片树叶的最长路径长，所有树叶的高度为0。
森林：由m（m>=0）棵互不相交的树的集合称为森林。

2. 树的分类

无序树
树中任意节点的子节点之间没有顺序关系。它就是一个无回路的连通图，没有确定根，在自由树中选定一顶点做根，则成为一棵通常的树。
有序树
树中任意节点的子节点之间有顺序关系。常见的有序树有：二叉树、完全二叉树、满二叉树、平衡二叉树（AVL树）、二叉查找树、霍夫曼树、B树、字典树。

3. 相关规律

二叉树

每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。左子树和右子树是有顺序的，次序不能任意颠倒。即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。
在二叉树的第 i 层上至多有$2^{i-1}$个结点（i≥1）。
深度为k的二叉树至多有$2^k-1$个结点（k≥1）。
对任何一棵二叉树，如果其叶子节点数为$n_0$，度为2的结点数为$n_2$，则$n_0=n_2 + 1$。（要会推导）

完全二叉树&&满二叉树

完全二叉树：对于一颗二叉树，假设其深度为d（d>1）。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列。
满二叉树：每一个层的结点数都达到最大值。
满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。
具有n个结点的完全二叉树的深度为$log_2n + 1$

平衡二叉树

它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
最小二叉平衡树的节点的公式：$F(n)=F(n-1)+F(n-2)+1$$

二叉查找树

二叉查找树又叫二叉排序树或二叉搜索树。是一棵空树，或者是具有下列性质的二叉树：

　　 1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
　　 2. 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
　　 3. 左、右子树也分别为二叉排序树；
　　 4. 没有键值相等的节点。
　　

二叉查找树的性质：对二叉查找树进行中序遍历，即可得到有序的数列。

霍夫曼树

带权路径最短的二叉树。是一个一般化的二叉查找树，可以拥有多于2个子节点。

B树

不是二叉树，是一个一般化的二叉查找树，可以拥有多于2个子节点。

字典树

Tire树称为字典树，又称单词查找树，Trie树用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。　
Tire树的三个基本性质：

　　 1. 根节点不包含字符，除根节点外每一个节点都只包含一个字符；
　　 2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串；
　　 3. 每个节点的所有子节点包含的字符都不相同。

相关实现(C++)

数组实现

using namespace std;
#include <iostream>
#include <vector>

/*
注意：对于结构体来说，如果TreeNode s；那么使用s.val
如果采用指针访问，TreeNode *s;那么使用s->val;
*/
struct TreeNode{
    char val;
    TreeNode *left;
    TreeNode *right;
};

void CreateTree(TreeNode* &root, char val[], int len, int index){
        if(index >= len){
            return;
        }

        if(val[index] != '*') {
            root = new TreeNode;
            root->val = val[index];
            root->left = root->right = NULL;
            CreateTree(root->left, val, len, 2 * index + 1);
            CreateTree(root->right, val, len, 2 * index + 2);
        }
        else{
          root = NULL;
        }
}

//树的深度优先搜索：DFS（前序遍历，后序遍历，中序遍历）
void pre_print(TreeNode* root){
        if(root){
            cout<<root->val<<' ';
        }
        if(root->left){pre_print(root->left);}
        if(root->right){pre_print(root->right);}
}

void post_print(TreeNode* root){
    if(root->left){post_print(root->left);}
    if(root->right){post_print(root->right);}
    if(root){
        cout<<root->val<<' ';
    }
}

void in_print(TreeNode* root){
    if(root->left){in_print(root->left);}
    if(root){
        cout<<root->val<<' ';
    }
    if(root->right){in_print(root->right);}
}

//树的广度优先搜索：BFS（层次遍历）
void level_print(TreeNode* root){
    vector<TreeNode> res;
    res.push_back(*root);

    int cur=0;
    int num;
    while(cur < res.size()){
        num = res.size();
        while(cur < num){
            cout<<res[cur].val<<' ';

            if(res[cur].left)
                res.push_back(*res[cur].left);
            if(res[cur].right)
                res.push_back(*res[cur].right);
            cur++;
        }
        cout<<endl;
    }
    }



int main() {
    char val[]= {'a','b','c','d','f','*','*','*','e','g'};
    int len = sizeof(val)/ sizeof(val[0]);
    TreeNode *root=NULL;
    CreateTree(root,val,len,0);

    cout<<"Pre-order traversal:"<<endl;
    pre_print(root);
    cout<<endl;

    cout<<"Post-order traversal:"<<endl;
    post_print(root);
    cout<<endl;

    cout<<"In-order traversal:"<<endl;
    in_print(root);
    cout<<endl;

    cout<<"Level-order traversal:"<<endl;
    level_print(root);
    cout<<endl;
    
    return 0;
}