4、【树形结构】树、B树、B+树、B*树

一、树的介绍

1. 树的定义

　　树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。

　　把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
　　(1) 每个节点有零个或多个子节点；
　　(2) 没有父节点的节点称为根节点；
　　(3) 每一个非根节点有且只有一个父节点；
　　(4) 除了根节点外，每个子节点可以分为多个不相交的子树。

2. 树的基本术语

　　若一个结点有子树，那么该结点称为子树根的"双亲"，子树的根是该结点的"孩子"。有相同双亲的结点互为"兄弟"。一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。

　　结点的度：结点拥有的子树的数目。
　　叶子：度为零的结点。
　　分支结点：度不为零的结点。
　　树的度：树中结点的最大的度。

　　层次：根结点的层次为1，其余结点的层次等于该结点的双亲结点的层次加1。
　　树的高度：树中结点的最大层次。
　　无序树：如果树中结点的各子树之间的次序是不重要的，可以交换位置。
　　有序树：如果树中结点的各子树之间的次序是重要的, 不可以交换位置。
　　森林：0个或多个不相交的树组成。对森林加上一个根，森林即成为树；删去根，树即成为森林。

二、二叉树的介绍

1. 二叉树的定义

　　二叉树是每个节点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。

2. 二叉树的性质

二叉树有以下几个性质：
　　性质1：二叉树第i层上的结点数目最多为 2^{i-1} (i≥1)。
　　性质2：深度为k的二叉树至多有2^{k}-1个结点(k≥1)。
　　性质3：包含n个结点的二叉树的高度至少为log₂ (n+1)。
　　性质4：在任意一棵二叉树中，若终端结点的个数为n₀，度为2的结点数为n₂，则n₀=n₂+1

3. 满二叉树，完全二叉树和二叉查找树

3.1 满二叉树

　　定义：高度为h，并且由2^{h} –1个结点的二叉树，被称为满二叉树。

3.2 完全二叉树

　　定义：一棵二叉树中，只有最下面两层结点的度可以小于2，并且最下一层的叶结点集中在靠左的若干位置上。这样的二叉树称为完全二叉树。
　　特点：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。

3.3 二叉查找树

　　定义：二叉查找树， 即二叉查找树(Binary Search Tree)，又被称为二叉搜索树。设x为二叉查找树中的一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] <= key[x]；如果y是x的右子树的一个结点，则key[y] >= key[x]。

在二叉查找树中：
　　(1) 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
　　(2) 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
　　(3) 任意节点的左、右子树也分别为B树。
　　(4) 没有键值相等的节点（no duplicate nodes）。

其具体结构如下图所示：

　　二叉查找树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中；否则，如果查询关键字比结点关键字小，就进入左儿子；如果比结点关键字大，就进入右儿子；如果左儿子或右儿子的指针为空，则报告找不到相应的关键字；

　　如果二叉查找树的所有非叶子结点的左右子树的结点数目均保持差不多（平衡），那么二叉查找树的搜索性能逼近二分查找；但它比连续内存空间的二分查找的优点是，改变二叉查找树结构（插入与删除结点）不需要移动大段的内存数据，甚至通常是常数开销；如：

  但二叉查找树在经过多次插入与删除后，有可能导致不同的结构：

　　右边也是一个二叉查找树，但它的搜索性能已经是线性的了；同样的关键字集合有可能导致不同的树结构索引；所以，使用B树还要考虑尽可能让二叉查找树保持左图的结构，和避免右图的结构，也就是所谓的“平衡”问题；      

       实际使用的二叉查找树都是在原二叉查找树的基础上加上平衡算法，即“平衡二叉树”；如何保持B树结点分布均匀的平衡算法是平衡二叉树的关键；平衡算法是一种在二叉查找树中插入和删除结点的策略；

 3.4 B树

 B树又称B-树，是一种平衡的多路查找树。B-树的阶是所有结点的孩子结点树的最大值。一棵m阶B-树，或为空树，或为满足下列特性的m叉树：

       （1）定义任意非叶子结点最多只有M个儿子；且M>2；

       （2）根结点的儿子数为[2, M]；

       （3）除根结点以外的非叶子结点的儿子数为[M/2, M]；

       （4）每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）

       （5）非叶子结点的关键字个数=指向儿子的指针个数-1；

       （6）非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；

       （7）非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；

       （8）所有叶子结点位于同一层；

 如：（M=3）

B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点；

B-树的特性：

       1.关键字集合分布在整颗树中；

       2.任何一个关键字出现且只出现在一个结点中；

       3.搜索有可能在非叶子结点结束；

       4.其搜索性能等价于在关键字全集内做一次二分查找；

       5.自动层次控制；

       由于限制了除根结点以外的非叶子结点，至少含有M/2个儿子，确保了结点的至少利用率，其最底搜索性能为：

 

　　其中，M为设定的非叶子结点最多子树个数，N为关键字总数；所以B-树的性能总是等价于二分查找（与M值无关），也就没有B树平衡的问题；由于M/2的限制，在插入结点时，如果结点已满，需要将结点分裂为两个各占M/2的结点；删除结点时，需将两个不足M/2的兄弟结点合并；

3.5 B+树

       B+树是B-树的变体，也是一种多路搜索树：

       （1）其定义基本与B-树同，除了：

       （2）非叶子结点的子树指针与关键字个数相同；

       （3）非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）；

       （4）为所有叶子结点增加一个链指针；

       （5）所有关键字都在叶子结点出现；

       如：（M=3）

　　B+的搜索与B-树也基本相同，区别是B+树只有达到叶子结点才命中（B-树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找；

       B+的特性：

       （1）所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的；

       （2）不可能在非叶子结点命中；

       （3）非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层；

       （4）更适合文件索引系统；

3.6 B*树

       是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针；

　　B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3（代替B+树的1/2）；

       B+树的分裂：当一个结点满时，分配一个新的结点，并将原结点中1/2的数据复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针；

       B*树的分裂：当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针；

       所以，B*树分配新结点的概率比B+树要低，空间使用率更高；

三、二叉查找树的C++实现

1. 节点和二叉查找树的定义

1.1 二叉查找树节点

struct BSTNode
{
    DataType data;
    BSTNode *lchild;
    BSTNode *rchild;
    BSTNode *parent;

    BSTNode(DataType x)
        :data(x), lchild(NULL), rchild(NULL), parent(NULL){};
};

 

BSTNode是二叉查找树的节点，它包含二叉查找树的几个基本信息：
　　(1) key -- 它是关键字，是用来对B树的节点进行排序的。
　　(2) left -- 它指向当前节点的左孩子。
　　(3) right -- 它指向当前节点的右孩子。
　　(4) parent -- 它指向当前节点的父结点。

2 遍历

　　这里讲解前序遍历、中序遍历、后序遍历3种方式。

2.1 前序遍历
若二叉查找树非空，则执行以下操作：
　　(1) 访问根结点；
　　(2) 前序遍历左子树；
　　(3) 前序遍历右子树。

2.2 中序遍历

若二叉查找树非空，则执行以下操作：
　　(1) 中序遍历左子树；
　　(2) 访问根结点；
　　(3) 中序遍历右子树。

 

2.3 后序遍历

若二叉查找树非空，则执行以下操作：
　　(1) 后序遍历左子树；
　　(2) 后序遍历右子树；
　　(3) 访问根结点。

前驱和后继

　　节点的前驱：是该节点的左子树中的最大节点。
　　节点的后继：是该节点的右子树中的最小节点。

【完整示例】

BSTree.h

typedef int DataType;

struct BSTNode
{
    DataType data;
    BSTNode *lchild;
    BSTNode *rchild;
    BSTNode *parent;

    BSTNode(DataType x)
        :data(x), lchild(NULL), rchild(NULL), parent(NULL){};
};


class BSTree {
public:
    BSTree();//构造函数
    ~BSTree();//析构函数
//定义外部接口函数
    //前序遍历
    void preOrder();
    //中序遍历
    void inOrder();
    //后序遍历
    void postOrder();
    //分层遍历
    void levelOrder();

    //查找键值为x的结点
    BSTNode *searchNode(DataType x);
    //将键值为x的结点插入二叉树
    void insertNode(DataType x);
    //删除键值为x的结点
    void removeNode(DataType x);
    //销毁二叉树
    void destroyBSTree();
    //打印二叉树
    void printBSTree();

    //查找键值最小的结点
    DataType minMem();
    //查找键值最大的结点
    DataType maxMem();

private://定义内部数据和接口函数
    BSTNode *root;    // 根结点

    // 前序遍历"二叉树"
    void preOrder(BSTNode *root);
    // 中序遍历"二叉树"
    void inOrder(BSTNode *root);
    // 后序遍历"二叉树"
    void postOrder(BSTNode *root);
    //分层遍历
    void levelOrder(BSTNode *root);

    //查找
    BSTNode * searchNode(BSTNode *root, DataType key);
    //插入
    void insertNode(BSTNode * &root, BSTNode *x);
    //删除
    BSTNode * removeNode(BSTNode *root, BSTNode *x);
    //销毁
    void destroyBSTree(BSTNode *root);

    //打印
    void printBSTree(BSTNode *root, DataType data, int direction);

    //查找最小结点
    BSTNode * minMem(BSTNode *root);
    //查找最大结点
    BSTNode * maxMem(BSTNode *root);
    //查找前驱
    BSTNode * predecessorode(BSTNode *x);
    //查找后继
    BSTNode * successorNode(BSTNode *x);

};

BSTree.cpp

#include <iostream>
#include <iomanip>
#include <queue>
#include "BSTree.h"

using namespace std;

//构造函数
BSTree::BSTree()
    :root(NULL)
{

}

//析构函数
BSTree::~BSTree()
{
    destroyBSTree();
}
//销毁二叉树 - 内部函数
void BSTree::destroyBSTree(BSTNode *bstnode)
{
    if(bstnode == NULL)
        return;
    if(bstnode->lchild != NULL)
        return destroyBSTree(bstnode->lchild);
    if(bstnode->rchild != NULL)
        return destroyBSTree(bstnode->rchild);
    delete bstnode;
    bstnode = NULL;
}
//销毁二叉树 - 外部函数
void BSTree::destroyBSTree()
{
    destroyBSTree(root);
}

//插入新结点 - 内部函数
void BSTree::insertNode(BSTNode * &bstnode, BSTNode *x)
{
    BSTNode *y = NULL;
    BSTNode *z = bstnode;

    //查找x的插入位置
    while(z != NULL)
    {
        y = z;
        if(x->data < z->data)
            z = z->lchild;
        else
            z = z->rchild;
    }
    x->parent = y;

    if(y == NULL)
    {
        bstnode = x;
    }
    else if(x->data < y->data)
    {
        y->lchild = x;
    }
    else
    {
        y->rchild = x;
    }
}
//插入新结点 - 外部函数
void BSTree::insertNode(DataType x)
{
    BSTNode *temp = new BSTNode(x);
    insertNode(root, temp);
}
//打印二叉树 - 内部函数
void BSTree::printBSTree(BSTNode *bstnode, DataType data, int direction)
{
    if(bstnode != NULL)
    {
        if(direction == 0)
            cout << setw(2) << bstnode->data << " is root " << endl;
        else
            cout << setw(2) << bstnode->data << " is "  << setw(2) << data << "`s"  << setw(12) << (direction == 1?"right child":"left child") << endl;
        printBSTree(bstnode->lchild, bstnode->data, -1);
        printBSTree(bstnode->rchild, bstnode->data, 1);
    }
}

//打印二叉树 - 外部函数
void BSTree::printBSTree()
{
    if(root == NULL)
        cout << "good job" << endl;
    if(root != NULL)
        printBSTree(root, root->data, 0);
}

//前序遍历 - 内部函数
void BSTree::preOrder(BSTNode *root)
{
    if(root != NULL)
    {
        cout << root->data << " ";
        preOrder(root->lchild);
        preOrder(root->rchild);
    }
}

//前序遍历 - 外部函数
void BSTree::preOrder()
{
    preOrder(root);
}

//中序遍历 - 内部函数
void BSTree::inOrder(BSTNode *root)
{
    if(root != NULL)
    {
        inOrder(root->lchild);
        cout << root->data << " ";
        inOrder(root->rchild);
    }
}

//中序遍历 - 外部函数
void BSTree::inOrder()
{
    inOrder(root);
}

//后续遍历 - 内部函数
void BSTree::postOrder(BSTNode *root)
{
    if(root != NULL)
    {
        postOrder(root->lchild);
        postOrder(root->rchild);
        cout << root->data << " ";
    }
}

//后续遍历 - 外部函数
void BSTree::postOrder()
{
    postOrder(root);
}

//分层遍历 - 内部函数
void BSTree::levelOrder(BSTNode *root)
{
    //这里使用队列存储二叉树的每个结点
    //队列的特性：先进先出
    queue<BSTNode *> q;
    BSTNode *p = root;
    q.push(p);

    while(!q.empty())
    {
        p = q.front();
        cout << p->data << " ";
        q.pop();

        if(p->lchild != NULL)
        {
            q.push(p->lchild);
        }
        if(p->rchild != NULL)
        {
            q.push(p->rchild);
        }
    }
    cout << endl;
}
//分层遍历 - 外部函数
void BSTree::levelOrder()
{
    levelOrder(root);
}

//查找键值为x的结点 - 内部函数
BSTNode * BSTree::searchNode(BSTNode *root, DataType x)
{
    if(root == NULL || root->data == x)
        return root;
    if(x < root->data)
        return searchNode(root->lchild, x);
    else
        return searchNode(root->rchild, x);
}

//查找键值为x的结点 - 外部函数
BSTNode * BSTree::searchNode(DataType x)
{
    searchNode(root, x);
}

//查找最小结点 - 内部函数
BSTNode * BSTree::minMem(BSTNode *root)
{
    if(root == NULL)
        return NULL;
    while(root->lchild != NULL)
        root = root->lchild;
    return root;
}
//查找最小结点 - 内部函数
DataType BSTree::minMem()
{
    BSTNode *p = minMem(root);
    if(p != NULL)
        return p->data;
    return (DataType)NULL;
}

//查找最大结点 - 内部函数
BSTNode * BSTree::maxMem(BSTNode *root)
{
    if(root == NULL)
        return NULL;
    while(root->rchild != NULL)
        root = root->rchild;
    return root;
}
//查找最大结点 - 外部函数
DataType BSTree::maxMem()
{
    BSTNode *p = maxMem(root);
    if(p != NULL)
        return p->data;
    return (DataType)NULL;
}
//查找结点x的后继结点，即查找二叉树中数据值大于该结点的最小值
BSTNode * BSTree::successorNode(BSTNode *x)
{
    //如果x存在右孩子， 则x的后继结点为“以其右孩子为根的子树的最小结点
    if(x->rchild != NULL)
        return minMem(x->rchild);
    //如果x没有右孩子，则x有以下两种可能：
    //（1）x是”一个左孩子“，则”x的后继结点“为”它的父结点“
    //（2）x是一个右孩子，则查找x的最低父结点，并且该父节点要有左孩子，
    //找到这个最低父节点就是x的后继结点
    BSTNode *y = x->parent;
    while((y != NULL) && (x == y->rchild))
    {
        x = y;
        y = y->parent;
    }
    return y;
}

//查找结点x的前驱结点，即查找二叉树中数据值小于该结点的最大值
BSTNode * BSTree::predecessorode(BSTNode *x)
{
    //如果x存在左孩子，则x的前驱结点就是以其左孩子为根的子树的最大结点
    if(x->lchild != NULL)
        return maxMem(x->lchild);
    //如果x没有左孩子，则x有以下两张可能
    //(1)x是一个右孩子，则x的前驱结点为它的父节点
    //(2)x是一个左孩子，则查找x的最低父节点，并且该父节点具有右孩子，
    //找到这个最低的父节点就是x的前驱结点
    BSTNode *y = x->parent;
    while((y != NULL) && (x == y->lchild))
    {
        x = y;
        y = y->parent;
    }
    return y;
}

//删除键值为x的结点，并返回该结点 - 内部函数
BSTNode * BSTree::removeNode(BSTNode *root, BSTNode *x)
{
    BSTNode *y = NULL;
    BSTNode *z = NULL;

    if((x->lchild == NULL) || (x->rchild == NULL))
        z = x;
    else
        z = successorNode(x);

    if(z->lchild != NULL)
        y = z->lchild;
    else
        y = z->rchild;

    if(y != NULL)
        y->parent = z->parent;

    if(z->parent == NULL)
        root = y;
    else if(z == z->parent->lchild)
        z->parent->lchild = y;
    else
        z->parent->rchild = y;

    if(z != x)
        x->data = z->data;

    return z;
}
//删除键值为x的结点，并返回该结点 - 外部函数
void BSTree::removeNode(DataType x)
{
    BSTNode *z, *node;
    if((z = searchNode(root, x)) != NULL)
        if((node = removeNode(root, z)) != NULL)
        delete node;
}

mian.cpp

#include <iostream>
#include "BSTree.h"

using namespace std;

static int arr[] = {1, 5, 4, 3, 2, 6};
#define SIZE(a) ((sizeof(a))/(sizeof(a[0])))

int main()
{
    int len;
    BSTree *bstree = new BSTree();

    //添加元素
    len = SIZE(arr);
    for(int i = 0; i < len; i++)
    {
        //cout << arr[i] << " ";
        bstree->insertNode(arr[i]);
    }
    bstree->levelOrder();
    cout << bstree->searchNode(4)->parent->data << endl;

    cout << "\n== 前序遍历: ";
    bstree->preOrder();

    cout << "\n== 中序遍历: ";
    bstree->inOrder();

    cout << "\n== 后序遍历: ";
    bstree->postOrder();

    cout << "\n== 层次遍历： ";
    bstree->levelOrder();
    cout << endl;

    cout << "== 最小值: " << bstree->minMem() << endl;
    cout << "== 最大值: " << bstree->maxMem() << endl;

    cout << "\n== 删除节点: " << arr[3];
    bstree->removeNode(arr[3]);

    cout << "\n== 中序遍历: ";
    bstree->inOrder();
    cout << endl;

    // 销毁二叉树
    bstree->destroyBSTree();
    //bstree->printBSTree();
    return 0;
}