设计算法统计二叉树(采用二叉链存储结构)中结点值为x的结点个数_数据结构与算法之美 | 数据结构中到底有多少种“树”？一文告诉你...

你学了这么多年数据结构，到底有多少种树，你知道吗？

数据结构中有很多树的结构，其中包括二叉树、二叉搜索树、2-3树、红黑树等等。本文中对数据结构中常见的几种树的概念和用途进行了汇总，不求严格精准，但求简单易懂。

• 1. 二叉树
  • 1.1 二叉树的定义
  • 1.2 二叉树的示例
  • 1.3 满二叉树和完全二叉树
    • 1.3.1 满二叉树
    • 1.3.2 完全二叉树
  • 1.4 二叉树的性质
• 2. 二叉查找树
• 3. 平衡二叉树
  • 3.1 平衡查找树之AVL树
  • 3.2 平衡二叉树之红黑树
• 4. B树
  • 4.1 什么是B树
  • 4.2 B树的性质
• 5. B+树
  • 5.1 什么是B+树
  • 5.2 B+的性质
• 6. B*树
• 7. R树
• 8. Trie树
  • 8.1 什么是Trie树
  • 8.2 Trie树的三个基本性质
  • 8.3 Tire树的应用

1. 二叉树

二叉树是数据结构中一种重要的数据结构，也是树表家族最为基础的结构。

1.1 二叉树的定义

二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

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

注：二叉树当中的结点只有度为0、1、2三种情况,度为0就是终端结点.构造二叉树的过程就是从原始结点开始“生长”结点的过程,初始状态下,原始结点就是终端结点,n0=1,n1=0,n2=0,每当一个原来的终端结点变成“1度结点”的时候只是把终端的位置向下移动了一点,n1++,不影响n0和n2,而每当一个原来的终端结点变成“2度结点”的时候,原来的终端消失,增加两个终端,总效果就是n0++,n2++,所以二叉树当中的n0和n2总是同步增加,即总是满足n0=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 完全二叉树

若设二叉树的深度为h，除第 h 层外，其它各层 (1～(h-1)层) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树。

注： 完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。

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. 二叉查找树

二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

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

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

二叉查找树的时间复杂度：它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡（比如，我们查找上图（b）中的“93”，我们需要进行n次查找操作）。我们追求的是在最坏的情况下仍然有较好的时间复杂度，这就是平衡查找树设计的初衷。

二叉查找树的高度决定了二叉查找树的查找效率。

二叉查找树的插入过程如下：

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){