数据结构与算法之美 | 数据结构中到底有多少种“树”？一文告诉你

• [1\. 二叉树](https://editor.csdn.net/md/?articleId=105180220#1__8)
• [1.1 二叉树的定义](https://editor.csdn.net/md/?articleId=105180220#11__11)
• [1.2 二叉树的示例](https://editor.csdn.net/md/?articleId=105180220#12__19)
• [1.3 满二叉树和完全二叉树](https://editor.csdn.net/md/?articleId=105180220#13__23)
• [1.3.1 满二叉树](https://editor.csdn.net/md/?articleId=105180220#131__25)
• [1.3.2 完全二叉树](https://editor.csdn.net/md/?articleId=105180220#132__34)
• [1.4 二叉树的性质](https://editor.csdn.net/md/?articleId=105180220#14__41)
• [2\. 二叉查找树](https://editor.csdn.net/md/?articleId=105180220#2__59)
• [3\. 平衡二叉树](https://editor.csdn.net/md/?articleId=105180220#3__269)
• [3.1 平衡查找树之AVL树](https://editor.csdn.net/md/?articleId=105180220#31_AVL_280)
• [3.2 平衡二叉树之红黑树](https://editor.csdn.net/md/?articleId=105180220#32__561)
• [4\. B树](https://editor.csdn.net/md/?articleId=105180220#4_B_1016)
• [4.1 什么是B树](https://editor.csdn.net/md/?articleId=105180220#41_B_1019)
• [4.2 B树的性质](https://editor.csdn.net/md/?articleId=105180220#42_B_1024)
• [5\. B+树](https://editor.csdn.net/md/?articleId=105180220#5_B_1051)
• [5.1 什么是B+树](https://editor.csdn.net/md/?articleId=105180220#51_B_1052)
• [5.2 B+的性质](https://editor.csdn.net/md/?articleId=105180220#52_B_1069)
• [6\. B*树](https://editor.csdn.net/md/?articleId=105180220#6_B_1083)
• [7\. R树](https://editor.csdn.net/md/?articleId=105180220#7_R_1098)
• [8\. Trie树](https://editor.csdn.net/md/?articleId=105180220#8_Trie_1105)
• [8.1 什么是Trie树](https://editor.csdn.net/md/?articleId=105180220#81_Trie_1106)
• [8.2 Trie树的三个基本性质](https://editor.csdn.net/md/?articleId=105180220#82_Trie_1110)
• [8.3 Tire树的应用](https://editor.csdn.net/md/?articleId=105180220#83_Tire_1115)

1. 二叉树

1.1 二叉树的定义

• 二叉树的第i层至多有2i-1个结点；
• 深度为k的二叉树至多有2k-1个结点；
• 对任何一棵二叉树T，如果其终端结点数为n_0n0​，度为2的结点数为n_2n2​，则n_0=n_2+1n0​=n2​+1。

1.2 二叉树的示例

1.3 满二叉树和完全二叉树

1.3.1 满二叉树

1. 一颗树深度为h，最大层数为k，深度与最大层数相同，k=h;
2. 叶子数为2h-1;
3. 第k层的结点数是：2k-1;
4. 总结点数是：2k-1，且总节点数一定是奇数。

1.3.2 完全二叉树

1.4 二叉树的性质

1. 在非空二叉树中，第i层的结点总数不超过2i-1, i>=1;
2. 深度为h的二叉树最多有2h-1个结点(h>=1)，最少有h个结点;
3. 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
4. 具有n个结点的完全二叉树的深度为 log_2 ⌊n⌋+1log2​⌊n⌋+1;
5. 有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

1. 给定N个节点，能构成h(N)种不同的二叉树，其中h(N)为卡特兰数的第N项，h(n)=C(2*n, n)/(n+1)h(n)=C(2∗n,n)/(n+1)。
2. 设有i个枝点，I为所有枝点的道路长度总和，J为叶的道路长度总和J=I+2iJ=I+2i。

2. 二叉查找树

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

1. 若当前的二叉查找树为空，则插入的元素为根节点;
2. 若插入的元素值小于根节点值，则将元素插入到左子树中;
3. 若插入的元素值不小于根节点值，则将元素插入到右子树中。

1. p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点），如图a;
2. p为单支节点（即只有左子树或右子树）。让p的子树与p的父亲节点相连，删除p即可（注意分是根节点和不是根节点），如图b;
3. p的左子树和右子树均不空。找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；或者方法二是找到p的前驱x，x一定没有右子树，所以可以删除x，并让x的父亲节点成为y的左子树的父亲节点。如图c。

struct node
{
    int val;
    pnode lchild;
    pnode rchild;
};

pnode BT = NULL;

//递归方法插入节点 
pnode insert(pnode root, int x)
{
    if(root == NULL){
    	pnode p = (pnode)malloc(LEN);
    	p->val = x;
    	p->lchild = NULL;
    	p->rchild = NULL;
        root = p;    
    }    
    else if(x < root->val){
        root->lchild = insert(root->lchild, x);    
    }
    else{
        root->rchild = insert(root->rchild, x);    
    }
    return root;
}

//非递归方法插入节点 
void insert_BST(pnode q, int x)
{
    pnode p = (pnode)malloc(LEN);
    p->val = x;
    p->lchild = NULL;
    p->rchild = NULL;
    if(q == NULL){
        BT = p;
        return ;    
    }        
    while(q->lchild != p && q->rchild != p){
        if(x < q->val){
            if(q->lchild){
                q = q->lchild;    
            }    
            else{
                q->lchild = p;
            }        
        }    
        else{
            if(q->rchild){
                q = q->rchild;    
            }    
            else{
                q->rchild = p;    
            }
        }
    }
    return;
}

bool delete_BST(pnode p, int x) //返回一个标志，表示是否找到被删元素 
{
    bool find = false;
    pnode q;
    p = BT;
    while(p && !find){  //寻找被删元素 
        if(x == p->val){  //找到被删元素 
            find = true;    
        }    
        else if(x < p->val){ //沿左子树找 
            q = p;
            p = p->lchild;    
        }
        else{   //沿右子树找 
            q = p;
            p = p->rchild;    
        }
    }
    if(p == NULL){   //没找到 
        cout << "没有找到" << x << endl;    
    }

    if(p->lchild == NULL && p->rchild == NULL){  //p为叶子节点 
        if(p == BT){  //p为根节点 
            BT = NULL;    
        }
        else if(q->lchild == p){   
            q->lchild = NULL;
        }        
        else{
            q->rchild = NULL;    
        }
        free(p);  //释放节点p 
    }
    else if(p->lchild == NULL || p->rchild == NULL){ //p为单支子树 
        if(p == BT){  //p为根节点 
            if(p->lchild == NULL){
                BT = p->rchild;    
            }    
            else{
                BT = p->lchild;    
            }
        }    
        else{
            if(q->lchild == p && p->lchild){ //p是q的左子树且p有左子树 
                q->lchild = p->lchild;    //将p的左子树链接到q的左指针上 
            }    
            else if(q->lchild == p && p->rchild){
                q->lchild = p->rchild;    
            }
            else if(q->rchild == p && p->lchild){
                q->rchild = p->lchild;    
            }
            else{
                q->rchild = p->rchild;
            }
        }
        free(p);
    }
    else{ //p的左右子树均不为空 
        pnode t = p;
        pnode s = p->lchild;  //从p的左子节点开始 
        while(s->rchild){  //找到p的前驱，即p左子树中值最大的节点 
            t = s;   
            s = s->rchild;    
        }
        p->val = s->val;   //把节点s的值赋给p 
        if(t == p){
            p->lchild = s->lchild;    
        }    
        else{
            t->rchild = s->lchild;    
        }
        free(s); 
    }
    return find;
}

pnode search_BST(pnode p, int x)
{
    bool solve = false;
    while(p && !solve){
        if(x == p->val){
            solve = true;    
        }    
        else if(x < p->val){
            p = p->lchild;    
        }
        else{
            p = p->rchild;    
        }
    }
    if(p == NULL){
        cout << "没有找到" << x << endl;    
    } 
    return p;
}

3. 平衡二叉树

3.1 平衡查找树之AVL树

1. 6节点的左子树3节点高度比右子树7节点大2，左子树3节点的左子树1节点高度大于右子树4节点，这种情况成为左左。
2. 6节点的左子树2节点高度比右子树7节点大2，左子树2节点的左子树1节点高度小于右子树4节点，这种情况成为左右。
3. 2节点的左子树1节点高度比右子树5节点小2，右子树5节点的左子树3节点高度大于右子树6节点，这种情况成为右左。
4. 2节点的左子树1节点高度比右子树4节点小2，右子树4节点的左子树3节点高度小于右子树6节点，这种情况成为右右。

3.2 平衡二叉树之红黑树

• 性质1\. 节点是红色或黑色。
• 性质2\. 根是黑色。
• 性质3\. 所有叶子都是黑色（叶子是NIL节点）。
• 性质4\. 每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个连续的红色节点。)
• 性质5\. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

• 性质1和性质3总是保持着。
• 性质4只在增加红色节点、重绘黑色节点为红色，或做旋转时受到威胁。
• 性质5只在增加黑色节点、重绘红色节点为黑色，或做旋转时受到威胁。

• 情形1: 该树为空树，直接插入根结点的位置，违反性质1，把节点颜色有红改为黑即可。
• 情形2: 插入节点N的父节点P为黑色，不违反任何性质，无需做任何修改。在这种情形下，树仍是有效的。性质5也未受到威胁，尽管新节点N有两个黑色叶子子节点；但由于新节点N是红色，通过它的每个子节点的路径就都有同通过它所取代的黑色的叶子的路径同样数目的黑色节点，所以依然满足这个性质。

注： 情形1很简单，情形2中P为黑色，一切安然无事，但P为红就不一样了，下边是P为红的各种情况，也是真正难懂的地方。

• 情形3: 如果父节点P和叔父节点U二者都是红色，(此时新插入节点N做为P的左子节点或右子节点都属于情形3,这里右图仅显示N做为P左子的情形)则我们可以将它们两个重绘为黑色并重绘祖父节点G为红色(用来保持性质4)。现在我们的新节点N有了一个黑色的父节点P。因为通过父节点P或叔父节点U的任何路径都必定通过祖父节点G，在这些路径上的黑节点数目没有改变。但是，红色的祖父节点G的父节点也有可能是红色的，这就违反了性质4。为了解决这个问题，我们在祖父节点G上递归地进行上述情形的整个过程（把G当成是新加入的节点进行各种情形的检查）。比如，G为根节点，那我们就直接将G变为黑色（情形1）；如果G不是根节点，而它的父节点为黑色，那符合所有的性质，直接插入即可（情形2）；如果G不是根节点，而它的父节点为红色，则递归上述过程（情形3）。

• 情形4: 父节点P是红色而叔父节点U是黑色或缺少，新节点N是其父节点的左子节点，而父节点P又是其父节点G的左子节点。在这种情形下，我们进行针对祖父节点G的一次右旋转; 在旋转产生的树中，以前的父节点P现在是新节点N和以前的祖父节点G的父节点。我们知道以前的祖父节点G是黑色，否则父节点P就不可能是红色(如果P和G都是红色就违反了性质4，所以G必须是黑色)。我们切换以前的父节点P和祖父节点G的颜色，结果的树满足性质4。性质5也仍然保持满足，因为通过这三个节点中任何一个的所有路径以前都通过祖父节点G，现在它们都通过以前的父节点P。在各自的情形下，这都是三个节点中唯一的黑色节点。

• 情形5: 父节点P是红色而叔父节点U是黑色或缺少，并且新节点N是其父节点P的右子节点而父节点P又是其父节点的左子节点。在这种情形下，我们进行一次左旋转调换新节点和其父节点的角色; 接着，我们按情形4处理以前的父节点P以解决仍然失效的性质4。注意这个改变会导致某些路径通过它们以前不通过的新节点N（比如图中1号叶子节点）或不通过节点P（比如图中3号叶子节点），但由于这两个节点都是红色的，所以性质5仍有效。

4. B树

4.1 什么是B树

blog.csdn.net/Charmve/art…