二叉搜索树用于实际查询的性能比较（c语言）

实际场景：

有一个公司想开发一个关于花卉的百科全书，用户只要输入花卉的名称，就能够输出花卉的详细信息。花卉包括：牡丹、芍药、茶花、菊花、梅花、兰花、月季、杜鹃花、郁金香、茉莉花、海棠、荷花、栀子花、莲花、百合、康乃馨、玫瑰、格桑花。公司也在试运行阶段发现这些花的访问频率不一，有些花经常性被访问，有些被访问的次数就少很多了。这18种花中，第1种的访问频率是6，第2-3种的访问频率是5，第4-6种的访问频率是4，第7-10种的访问频率是3，第11-15种的访问频率是2，第16-18种的访问频率是1。

这个公司想提升花卉检索效率，所以对比了三种方法。

1. 随机构建二叉搜索树（randomly built BST），进行搜索。
2. 将这些花卉按照访问频度从高到低放在一个数组中，并顺序访问来检索
3. 构建哈希表来存储这些数据，并基于哈希表来检索数据。

数据集构建：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include<windows.h>
#define NUM 18

char nameData[18][25]={"牡丹","芍药","茶花","菊花","梅花","兰花","月季","杜鹃花","郁金香","茉莉花","海棠","荷花","栀子花","莲花","百合","康乃馨","玫瑰","格桑花"};
int frequencyData[18]={6,5,5,4,4,4,3,3,3,3,2,2,2,2,2,1,1,1};
typedef struct total
{
    char name[25];
    int fre;
}Total;
Total fre_name[NUM];//存放数据

这里构建了一个较小的数据集，用于后面的查询比较。后面的查询基于fre_name数组。

随机二叉搜索树用于查询的代码：

下面是具体代码，包括结构体定义，插入操作，查询操作等。

//---------------------------------随机二叉搜索树方法-----------------------------------
//是否插入记录
int IsInsert[NUM]={0};//未插入为0

//二叉搜索树结点
typedef struct node
{
    char data[25];//存放花名字
    int key;//关键字，花访问频率
    struct node *left,*right,*parent;//父节点，子结点
}Node;

//构建树结构
typedef struct tree
{
    Node *root;
}Tree;

//插入函数（二叉搜索树）
void BTreeInsert(Tree *t,Node *p)
{
    Node *x=t->root;
    Node *y=NULL;
    while(x != NULL)
    {
        y=x;
        if(p->key < x->key)x=x->left;
        else x=x->right;
    }
    p->parent=y;
    if(y==NULL)t->root=p;
    else if(p->key < y->key)y->left=p;
    else y->right=p;
}

//实现随机插入
void RandomInsert(Tree *t)
{
    srand((unsigned)time(NULL));//设置随机种子
    int index,count=0;//count用来记录
    while(1)
    {
        if(count==NUM)break;
        index=rand()%NUM;
        if(IsInsert[index]!=0)continue;
        IsInsert[index]=1;
        //构建插入元素
        Node *p=(Node*)malloc(sizeof(Node));
        p->key=frequencyData[index];
        strcpy(p->data,nameData[index]);
        p->left=NULL;
        p->right=NULL;
        BTreeInsert(t,p);
        count++;
    }
}

//返回访问频率
int Change(char name[])
{
    int i;
    for(i=0;i<NUM;i++)
    {
        if(!strcmp(name,nameData[i]))return frequencyData[i];
    }
}

//查询操作,花名查询
void Search(Tree t,Node *p,char name[])
{
    int fre=Change(name);
    if(fre == p->key)
    {
        if(!strcmp(p->data,name))
        {
            printf("查询成功！\n");
            return;
        }
    }
    if(fre < p->key)
    {
        if(p->left==NULL)
        {
            printf("无查询结果！\n");
            return;
        }
        Search(t,p->left,name);
    }
    if(fre >= p->key)
    {
        if(p->right==NULL)
        {
            printf("无查询结果！\n");
            return;
        }
        Search(t,p->right,name);
    }
}
//------------------------------------随机二叉树方法--------------------------------------

直接通过数组查询的代码：

将这些花卉按照访问频度从高到低放在一个数组中，并顺序访问来检索，代码如下：

//------------------------------------顺序数组法-------------------------------------------

void ArraySearch(char name[])
{
    int i=0;
    for(i=0;i<NUM;i++)
    {
        if(!strcmp(name,nameData[i]))
        {
            printf("查询成功！\n");
            return;
        }
    }
    printf("无查询结果！\n");
}
//------------------------------------顺序数组法-------------------------------------------

基于哈希表的查询：

哈希表采用链式方法解决哈希冲突，代码如下：

//-----------------------------------哈希表法---------------------------------------------
//哈希表采用链式解决冲突

//存储结构
typedef struct hashnode
{
    char data[25];
    int key;
    struct hashnode *next,*parent;
}HashNode;
//数组，首元素存放地址
HashNode* HashTable[11];
//HashTable初始化
void HashInit(void)
{
    int i;
    for(i=0;i<11;i++)HashTable[i]=NULL;
}

//哈希函数
int hash(int n)
{
    return n%11;
}

//构建哈希表
void HashInsert(void)
{
    int i;
    for(i=0;i<NUM;i++)
    {
        HashNode *p=(HashNode*)malloc(sizeof(HashNode));
        int m=hash(frequencyData[i]);
        strcpy(p->data,nameData[i]);
        p->key=frequencyData[i];
        p->next=NULL;
        if(HashTable[m]==NULL)//该槽位为空
        {
            HashTable[m]=p;
            HashTable[m]->parent=NULL;
        }
        else
        {
            if(HashTable[m]->next==NULL)
            {
                p->parent=HashTable[m];
                HashTable[m]->next=p;
            }
            else
            {
                p->parent=HashTable[m];
                p->next=HashTable[m]->next;
                HashTable[m]->next->parent=p;
                HashTable[m]->next=p;
            }
        }
    }
}

//在哈希表中查询
void HashSearch(Totle t)
{
    int m=t.fre;
    m=hash(m);
    HashNode *p=HashTable[m];
    while(p != NULL)
    {
        if(!strcmp(p->data,t.name))
        {
            printf("查询成功！\n");
            return;
        }
        p=p->next;
    }
    printf("无查询结果！\n");
}


//-----------------------------------哈希表法---------------------------------------------

实际查询性能结果：

对于不同查找方法，我重复了100次得到平均查找时间，每次查找我以访问频率作为对不同元素的查找次数，得到了以下数据：

查询方法	二叉搜索树	数组	哈希表
平均运行时间(s)	0.0510385	0.04948571	0.0478331

得到了如下图像：

可以看到上面不同方法运行时间相近，也就是这三种方法在这种情况下查找性能相近，二叉搜索树进行单次查找的时间为O(h),其中h为最大深度。如果二叉搜索树是完全二叉树那么速度将会快很多，但是随机构建二叉搜索树会导致二叉树不均匀，并且不同元素有相同的访问频率也会导致二叉搜索树不均匀，导致其访问时间不够快。对于哈希表的方法，由于数据规模不够大，所以哈希表也没有体现出太大优势。

 随机二叉搜索树的性能不如其他两种的原因可能是因为其运行时间的波动大。

二叉搜索树是随机构建的，所以在每一次重复进行实验时，运行时间会有比较大的波动，下面是重复100次实验二叉搜索树进行查找的时间图：

从这幅图可以看到，随机二叉搜索树进行查找操作的运行时间波动很大，所以有时候其平均性能并不是很好。但是可以看出，其在比较好的情况下，性能是优于数组方法的。

实验结果分析：

1.二叉搜索树的查找时间为O(h),其中h为最大深度，但是二叉搜索树的深度与元素插入顺序有关，所以重复实验时运行时间会有较大的波动（如图二）选取前50小的值得到平均值0.0150897，而数组方法的平均值为0.01680286，可以看出随机二叉搜索树的查找时间受波动影响很大。

2.在上述所给数据规模下，三种方法的平均运行时间差异较小，当数据规模较大的时候，随机二叉搜索树和哈希表的方法会体现出更大优势。

3.用数组的方法，在数据规模较小时会有很大优势，因为随机二叉搜索树和哈希表的构建所需要的时间较多，所以这时候查找省下的时间远少于构建所多消耗的时间，所以用数组的方法更有优势。