功能强大的Trie数据结构 SDK

 

 

 

 

1.  概述

本文档适用于C语言开发人员，用于在开发过程中进行参考，文档详细讲述每个

函数的用法以及源码示例。

 

1.  版本说明

 

 

略

1.  定义说明
2.   术语定义

1、Trie树

   略

      

1. 根节点

Trie树的根节点，对应键值为空的节点。根节点没有父节点。

 

1. 实节点

指Trie树中存在用户数据的节点

 

1. 虚节点

指Trie树中不存在用户数据的节点

 

5、父节点

    指定节点的直接父亲节点。

 

6、子节点

    指定节点的直接孩子结点

 

1. 兄弟节点

兄弟节点间拥有同一个父节点。

 

1. 头节点

Trie树中键值最小的实节点

 

1. 尾节点

Trie树中键值最大的实节点

 

1. 下一节点

Trie树中键值比当前节点大的第一个实节点

 

11、上一节点

Trie树中键值比当前节点小的第一个实节点

 

12、节点用户数据

每个节点都有一个变量保存外部设置给该节点的数据，为HANDLE数据类型。

 

1.  头文件定义

1、HMHTREE

   指向一个Trie树的句柄，即指向Trie树的指针，定义如下：

   typedef void* HMHTREE;

 

2、POSITION

   POSITION定义为一个指向Trie实节点的指针，定义如下：

    typedef void* POSITION;

 

3、HANDLE

定义如下：

    typedef void* HANDLE;

    在本文里指Trie节点中用户数据

 

4、ONMHDELETE

ONMHDELETE为回调函数指针，在执行MHDeleteTree和MHRemoveAll

函数释放树节点时，对每个被删除的节点都执行此回调函数，在回调函数中

处理与节点相关的操作。

 

定义如下：

typedef bool (* ONMHDELETE)(POSITION pos, void* pInputPara);

参数：

1）POSITION pos

       被删除实节点句柄（指针）

 

    2）void* pInputPara

输入参数指针，由MHDeleteTree和MHRemoveAll函数的参数中提供。

 

1.  Trie树功能函数
2.  MHCreateTree()

1、功能说明

此函数用来生成Trie树，执行成功后返回新生成树的句柄，之后对此树的操作都引用此句柄。

 

2、函数原型

HMHTREE MHCreateTree(int nDataType);

 

3、参数说明

   1) int nDataType

       Trie树键值的数据类型，支持以下数据类型：

 

    enum TrieDataType

{

    TRIE_INT8       = 1,

    TRIE_UINT8      = 2,

    TRIE_INT16      = 3,

    TRIE_UINT16     = 4,

    TRIE_INT32      = 5,

    TRIE_UINT32     = 6,

    TRIE_INT64      = 7,

    TRIE_UINT64     = 8,

    TRIE_Float      = 9,

    TRIE_Double     = 10,

    TRIE_STRING     = 12,

    。。。。。。。。

};

说明如下：

TRIE_INT8：   1字节有符号整数

    TRIE_UINT8：  1字节无符号整数

    TRIE_INT16：  2字节有符号整数

    TRIE_UINT16： 2字节无符号整数

    TRIE_INT32 ：  4字节有符号整数

    TRIE_UINT32： 4字节无符号整数

    TRIE_INT64 ：  8字节有符号整数

    TRIE_UINT64： 8字节无符号整数

    TRIE_Float：  4字节浮点数（暂时不支持）

    TRIE_Double： 8字节浮点数（暂时不支持）

TRIE_STRING： 以\0结尾的字符串

 

4、返回值

执行成功返回非NULL的句柄，否则返回NULL。

 

5、相关函数

   MHDeleteTree()

 

示例：参考MHAddKey

 

1.  MHDeleteTree()

1、功能说明

此函数用来删除Trie树以及树节点占用的空间，删除后的Trie树，不能再

被引用。

 

2、函数原型

void MHDeleteTree(HMHTREE hTree, ONMHDELETE OnDelete = NULL,

void* pInputPara = NULL);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄。

 

   2）ONMHDELETE OnDelete

      参考第3章定义说明部分。

 

3）void* pInputPara

      参考第3章定义说明部分。

 

4、返回值

    无

 

5、相关函数

   MHCreateTree()

   MHAddKey()

   MHRemoveAll()

                                                      

示例：参考MHAddKey

 

1.  MHAddKey()

1、功能说明

此函数用来在Trie树中插入一个实节点。

 

2、函数原型

bool MHAddKey(HMHTREE hTree, char sKey, HANDLE hValue, POSITION& pos);

 

3、参数说明

   1）HANDLE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2）char* sKey

插入到Trie树中的键值，不管Trie树的数据类型是什么，都必须转换成以\0结尾字符串形式。

对各种数据类型的键值形式规范定义如下：

（1）TRIE_INT8

     TRIE_UINT8

TRIE_INT16

TRIE_UINT16

TRIE_INT32

TRIE_UINT32

TRIE_INT64

TRIE_UINT64

TRIE_Float

TRIE_Double

      负数：

      例如：-12

      0：

      例如：0或者+0

      正数：

      例如：12或者+12

      注意：数字类型的sKey值不能为空，表达的值也不能越界。

 

  （2）GString

      sKey的长度可以为0,目前最大的长度不能超多16K字节。

 

3）HANDLE hValue

  插入节点的用户数据，一般为结构体或对象的指针。

 

4）POSITION& pos;

输出参数，返回新增节点的句柄，如果新增节点失败，pos值为NULL。

 

4、返回值

    1）true 则说明插入成功，在hTree中成功生成一个新数据节点。

   2）false 则说明插入失败，在树中已经存在相同键值的数据节点。

 

5、相关函数

   MHRemoveKey()

MHGetCount()

   MHRemoveAll()

 

示例1：

功能：在树插入键值。

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos));

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       printf(“Element count: %d\r\n”, MHGetCount(hTree));

 

MHDeleteTree(hTree, OnDelete, ”demo”);

 

    return 0;

}                         

1.  MHRemoveKey()

1、功能说明

此函数用来在Trie树中删除指定的实节点，被删除的实节点由函数参数提供

的键值确定。

 

2、函数原型

bool MHRemoveKey(HMHTREE hTree, char* sKey, HANDLE& hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2）void* sKey

 输入参数，删除节点的键值

 

3）HANDLE& hValue

 输出参数

 返回要删除节点的用户数据句柄（指针）

 

4、返回值

    返回值为被删除数据节点的句柄值。

    1）!= NULL 则说明在hTree中成功删除一个实节点。

   2）NULL 则说明在hTree中不存在指定键值的实节点。

 

5、相关函数

   MHAddKey()

MHGetCount()

   MHRemoveAll()

 

示例1：

功能：在1级树中删除一个数据节点。

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

 

       printf(“Element count: %d\r\n”, MHGetCount (hTree));

 

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       printf(“Element count: %d\r\n”, MHGetCount (hTree));

 

       // 删除指定键值的数据节点

       char* sCardID = “123456789012345670”;

      

HANDLE hValue; 

       MHRemoveKey(hTree, sCardID, hValue);

       pRetInfo = LPPERSONINFO(hValue);

       printf("%s,%d,%s,%d,%s,%s\r\n", pRetInfo->sCardID, pRetInfo->nSex,

              pRetInfo->sName, pRetInfo->nAge, pRetInfo->sAddress, pRetInfo->sEmail);

 

       printf(“Element count: %d\r\n”, MHGetCount(hTree));

 

       MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

 

1.  MHGetCount()

1、功能说明

此函数用来获取Trie树中实节点的数量。

 

2、函数原型

int MHGetCount(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

4、返回值

    1）大于等于0的整数。

 

5、相关函数

MHAddKey()

   MHRemoveKey()

   MHRemoveAll()

 

示例：参考MHAddKey、MHRemoveKey

1.  MHRemoveAll()

1、功能说明

此函数用来删除Trie树的所有节点。

 

2、函数原型

void MHRemoveAll(HMHTREE hTree, ONMHDELETE OnDelete = NULL,

void* pInputPara = NULL);

 

3、参数说明

   1）HMHTRIE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

   2）参考定义说明

   3）参考定义说明

4、返回值

    无

 

5、相关函数

MHAddKey()

   MHGetCount()

   MHRemoveKey()

 

示例：

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos));

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

 

       printf(“Element count: %d\r\n”, MHGetCount(hTree));

 

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       printf(“Element count: %d\r\n”, MHGetCount(hTree));

      

MHRemoveAll(hTree, OnDelete, “demo“);

      

       printf(“Element count: %d\r\n”, MHGetCount(hTree));

 

MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

 

1.  MHGetKeyPosition()

1、功能说明

此函数用来根据键值在Trie树中查询实节点，返回实节点的句柄。

 

2、函数原型

POSITION MHGetKeyPosition(HMHTREE hTree, char* sKey);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

2) char* sKey

查询实节点的键值

 

4、返回值

    返回节点的句柄，如果返回值为NULL，则没有查询到节点。

  

5、相关函数  

MHAddKey()

MHRemoveKey()

MHRemoveAll()

MHGetKeyValue()

 

示例1：

功能：在树中精确查询实节点句柄。

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

      

AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       char* sCardID = “123456789012345678”;

 

// 查询节点

       POSITION pos;

pos = HTreeGetKeyPosition (hTree, sCardID);

 

       HANDLE hValue; 

hValue = MHGetPosValue(pos);

      

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);

       printf(“CardID: %s”, pRetInfo->sCardID);

      

MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

 

1.  MHGetKeyValue()

1、功能说明

根据键值在Trie树中精确匹配实节点，并返回实节点的句柄值。

 

2、函数原型

bool MHGetKeyValue(HANDLE hTree, char* sKey, HANLDE& hValue);

 

3、参数说明

   1）HANDLE hTree

      HASH树的句柄，此句柄由MHCreateTree函数生成。

 

2）char* sKey

  查询实节点的键值

 

3) HANDLE& hValue

  输出参数，返回实节点用户数据

 

4、返回值

    true：查询到该键值的节点

    false：没有此键值的节点

 

5、相关函数

   MHAddKey()

MHGetCount()

   MHRemoveAll()

 

示例1：

功能：在树中精确查询节点。

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

      

AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       char* sCardID = “123456789012345678”;

 

// 查询节点

       HANDLE hValue; 

HTreeGetKeyValue(hTree, sCardID, hValue);

      

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);

       printf(“CardID: %s”, pRetInfo->sCardID);

      

MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

1.  MHGetMatchValue()

1、功能说明

根据键值在Trie树中进行反向模糊(前缀)匹配，返回符合条件的实节点的用户数据句柄。

 

2、函数原型

bool HTreeGetMatchValue(HANDLE hTree, char* sKey, bool bAsc,

HANDLE& hValue);

 

3、参数说明

   1）HANDLE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2）char* sKey

用于模糊匹配的文本。

 

3）bool bAsc

true： 返回最不精确的实节点。

false： 返回最精确的实节点。

 

4) HANDLE& hValue

  输出参数，返回实节点用户数据

 

4、返回值

    1）true, 则说明在Trie树中成功匹配到一个实节点。

   2）false, 则说明在Trie树中没有匹配到一个实节点。

 

5、相关函数

   MHAddKey()

MHGetCount()

   MHGetMatchPosition()

 

示例1：

功能：在树中反向匹配数据节点。

 

#include <stdio.h>

#include <string.h>

#include "TrieAPI.h"

 

typedef struct _PREFIXINFO

{

       char sPrefix[32];

       char sData[32];

} PREFIXINFO;

typedef PREFIXINFO * LPPREFIXINFO;

 

int AddPrefixInfo(HANDLE hTree,char* sPrefix, char* sData)

{    

       LPPREFIXINFO pPrefixInfo;

       pPrefixInfo = new PREFIXINFO;

      

       strcpy(pPrefixInfo->sPrefix, sPrefix);

       strcpy(pPrefixInfo->sData, sData);

      

       POSITION pos;

       return(MHAddKey(hTree, sPrefix, pPrefixInfo, pos));

}

 

int main(int nArgc, char* sArgv[])

{           

       HMHTREE hTree;                     

       hTree = MHCreateTree(TRIE_STRING);

      

       AddPrefixInfo(hTree, "%", "0");

       AddPrefixInfo(hTree, "1%", "1");

       AddPrefixInfo(hTree, "12%", "12");

       AddPrefixInfo(hTree, "123%", "123");

       AddPrefixInfo(hTree, "1234%", "1234");

       AddPrefixInfo(hTree, "12345%", "12345");

       AddPrefixInfo(hTree, "123456%", "123456");

       AddPrefixInfo(hTree, "1234567%", "1234567");

       AddPrefixInfo(hTree, "12345678%", "12345678");

       AddPrefixInfo(hTree, "123456789%", "123456789");

             

       HANDLE hValue;

       bool bRet;

       bRet = MHGetMatchValue(hTree, "1234567890", true, hValue);

      

       LPPREFIXINFO pRetInfo;  

       pRetInfo = LPPREFIXINFO(hValue); 

       printf("%s,%s\r\n", pRetInfo->sPrefix, pRetInfo->sData);

             

       bRet = MHGetMatchValue(hTree, "1234567890", false, hValue);

      

       pRetInfo = LPPREFIXINFO(hValue); 

       printf("%s,%s\r\n", pRetInfo->sPrefix, pRetInfo->sData);

      

       MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

 

1.  MHGetMatchPostion()

1、功能说明

根据键值在Trie树中进行反向模糊(前缀)匹配，返回符合条件的实节点句柄。

 

2、函数原型

POSITION HTreeGetMatchValue(HANDLE hTree, char* sKey, bool bAsc);

 

3、参数说明

   1）HANDLE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2）char* sKey

用于模糊匹配的文本。

 

3）bool bAsc

true： 返回最不精确的实节点。

false： 返回最精确的实节点。

 

4、返回值

    1）!= NULL, 则说明在Trie树中成功匹配到一个实节点。

   2）NULL, 则说明在Trie树中没有匹配到一个实节点。

 

5、相关函数

   MHAddKey()

MHGetCount()

   MHGetMatchValue()

 

示例1：

功能：在树中反向匹配数据节点。

 

#include <stdio.h>

#include <string.h>

#include "TrieAPI.h"

 

typedef struct _PREFIXINFO

{

       char sPrefix[32];

       char sData[32];

} PREFIXINFO;

typedef PREFIXINFO * LPPREFIXINFO;

 

int AddPrefixInfo(HANDLE hTree,char* sPrefix, char* sData)

{    

       LPPREFIXINFO pPrefixInfo;

       pPrefixInfo = new PREFIXINFO;

      

       strcpy(pPrefixInfo->sPrefix, sPrefix);

       strcpy(pPrefixInfo->sData, sData);

      

       POSITION pos;

       return(MHAddKey(hTree, sPrefix, pPrefixInfo, pos));

}

 

int main(int nArgc, char* sArgv[])

{           

       HMHTREE hTree;                     

       hTree = MHCreateTree(TRIE_STRING);

      

       AddPrefixInfo(hTree, "%", "0");

       AddPrefixInfo(hTree, "1%", "1");

       AddPrefixInfo(hTree, "12%", "12");

       AddPrefixInfo(hTree, "123%", "123");

       AddPrefixInfo(hTree, "1234%", "1234");

       AddPrefixInfo(hTree, "12345%", "12345");

       AddPrefixInfo(hTree, "123456%", "123456");

       AddPrefixInfo(hTree, "1234567%", "1234567");

       AddPrefixInfo(hTree, "12345678%", "12345678");

       AddPrefixInfo(hTree, "123456789%", "123456789");

             

       HANDLE hValue;

       POSITION pos;

 

       pos = MHGetMatchPosition(hTree, "1234567890", true);

       hValue = MHGetPosValue(pos);

      

       pRetInfo = LPPREFIXINFO(hValue); 

       printf("%s,%s\r\n", pRetInfo->sPrefix, pRetInfo->sData);

      

       char sKey[256];    

       MHGetPosKey(pos, sKey);        

       printf("%s\r\n", sKey);

 

       pos = MHGetMatchPosition(hTree, "1234567890", false);     

       hValue = MHGetPosValue(pos);

      

       pRetInfo = LPPREFIXINFO(hValue); 

       printf("%s,%s\r\n", pRetInfo->sPrefix, pRetInfo->sData);

             

       MHGetPosKey(pos, sKey);        

      

       printf("%s\r\n", sKey);

      

       MHDeleteTree(hTree, OnDelete, “demo“);

 

    return 0;

}

1.  MHGetHead()

1、功能说明

此函数返回Trie树中的头节点即键值最小的实节点的句柄值。

 

2、函数原型

bool MHGetHead(HMHTREE hTree, HANDLE& hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2) HANDLE& hValue

  输出参数，返回头节点的句柄值。

 

4、返回值

    true: 执行成功

    false: Trie树中无节点

 

5、相关函数

   MHGetHeadPosition()

MHGetTail()

   MHGetTailPosition()

 

示例1：

功能：在树中获取头节点句柄值。

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

 

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       HANDLE hValue;

      

       // 获取头节点

MHGetHead(hTree, hValue);// 获取的是” 123456789012345670”节点

      

LPPERSONINFO pPersonInfo;

       pRetInfo = LPPERSONINFO(pPersonInfo);      

       printf(“CardID: %s\r\n”, pPersonInfo ->sCardID);     

 

       // 获取尾节点

MHGetTail(hTree, hValue);// 获取的是” 123456789012345679”节点

      

       pRetInfo = LPPERSONINFO(pPersonInfo);      

       printf(“CardID: %s\r\n”, pPersonInfo ->sCardID);     

 

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

 

1.  MHGetTail()

1、功能说明

此函数返回Trie树中的头节点即键值最大的实节点的句柄值。

 

2、函数原型

bool MHGetTail(HMHTREE hTree, HANDLE& hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2) HANDLE& hValue

  输出参数，返回尾节点的句柄值。

 

4、返回值

    true: 执行成功

    false: Trie树中无节点

 

5、相关函数

MHGetHead()

    MHGetHeadPosition()

    MHGetTailPosition()

 

1.  MHRemoveHead()

1、功能说明

此函数删除Trie树中的头节点即键值最小的节点，同时返回被删除节点的句柄值。

 

2、函数原型

bool MHRemoveHead(HMHTREE hTree, HANDLE& hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

2) HANDLE& hValue

  输出参数，返回被删除头节点的句柄值。

 

4、返回值

    true: 成功删除头结点

    false: 树中无节点

 

5、相关函数

   MHGetHeadPosition()

MHGetTail()

   MHGetTailPosition()

MHGetRemoveTail()

 

示例1：

功能：在树中删除头节点。

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

       POSITION pos; lp6

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

    hTree = MHCreateTree(TRIE_STRING);

 

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);         

 

       HANDLE hValue; 

       // 删除的头节点

       MHRemoveHead(hTree, hValue);// 删除的是” 123456789012345670”节点

      

LPPERSONINFO pPersonInfo;

       pPersonInfo = LPPERSONINFO(hValue);  

       printf(“CardID: %s\r\n”, pPersonInfo ->sCardID);     

 

       // 删除降序的头节点

MHRemoveTail(hTree, hValue);// 获取的是” 123456789012345679”节点

      

       pPersonInfo = LPPERSONINFO(hValue);  

       printf(“CardID: %s\r\n”, pPersonInfo->sCardID);      

      

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

1.  MHRemoveTail()

1、功能说明

此函数删除Trie树中的尾节点即键值最大的节点，同时返回被删除节点的句柄值。

 

2、函数原型

bool MHRemoveTail(HMHTREE hTree, HANDLE& hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

2) HANDLE& hValue

  输出参数，返回被删除尾节点的句柄值

 

4、返回值

    true: 成功删除尾结点

    false: 树中无节点

  

5、相关函数  

MHRemoveHead()

 

1.  MHGetHeadPostion()

1、功能说明

此函数用来返回Trie树中的头节点即键值最小的实节点。

 

2、函数原型

POSITION MHGetHeadPosition(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄，如果Trie树中没有实节点返回值为NULL，否则返回非空

    值。

  

5、相关函数  

MHGetNextPosition()

MHGetPrevPosition()

MHGetTailPosition()

 

示例1：

功能：遍历Trie树中节点。

 

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

    char sCarID[19];

    char sName[16];

    char nSex;

    short nAge;

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

 

LPPERSONINFO pPersonInfo;

 

int i;

for(i = 0; i < 10; i++)

{

pPersonInfo = new PERSONINFO;

sprintf(pPersonInfo->sCardID, “12345678901234567%d”, i);

sprintf(pPersonInfo->sName, “zhang%d”, i);

pPersonInfo->nSex = 1;

pPersonInfo->nAge = 20 + i;

POSITION pos;

MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos);

}

 

HANDLE hValue;

POSITION pos;

// 升序遍历

pos = MHGetHeadPosition(hTree);

While(pos != NULL)

{

    hValue = MHGetPosValue(pos);

 

        LPPERSONINFO pPersonInfo;

pPersonInfo = LPPERSONINFO(hValue);

printf(“cardid: %s name: %s sex: %d age: %d\r\n”,

       pPersonInfo->sCardID, pPersonInfo->sName, pPersonInfo->nSex,

            pPersonInfo->nAge);

 

    pos = MHGetNextPosition(pos)

}

// 降序遍历

pos = MHGetTailPosition(hTree);

While(pos != NULL)

{

    hValue = MHGetPosValue(pos);

 

        LPPERSONINFO pPersonInfo;

pPersonInfo = LPPERSONINFO(hValue);

printf(“cardid: %s name: %s sex: %d age: %d\r\n”,

       pPersonInfo->sCardID, pPersonInfo->sName, pPersonInfo->nSex,

            pPersonInfo->nAge);

 

    pos = MHGetPrevPosition(pos)

}

 

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

 

1.  MHGetNextPosition()

1、功能说明

此函数用来返回Trie树中指定实节点的下一个实节点,下一个实节点的键值

大于当前实节点的键值,如果当前节点是最后一个实节点，则返回NULL。

 

2、函数原型

POSITION MHGetNextPosition(HMHTREE hTree, POSITION pos);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

    2）POSITION pos

       指定实节点句柄

 

4、返回值

    返回实节点句柄，如果Trie树中没有实节点返回值为NULL，否则返回非空

    值。

  

5、相关函数  

MHGetHeadPosition()

MHGetPrevPosition()

MHGetTailPosition()

 

示例：参考MHGetHeadPosition

 

1.  MHGetPrevPosition()

1、功能说明

此函数用来返回Trie树中指定实节点的上一个实节点,上一个实节点的键值小于当前实节点的键值,如果当前节点是头实节点，则返回NULL。

 

2、函数原型

POSITION MHGetPrevPosition(HMHTREE hTree, POSITION pos);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

    2）POSITION pos

       指定节点

 

4、返回值

    返回实节点句柄，如果Trie树中没有实节点返回值为NULL，否则返回非空

    值。

  

5、相关函数  

MHGetHeadPosition()

MHGetNextPosition()

MHGetTailPosition()

 

示例：参考MHGetHeadPosition

 

1.  MHGetTailPostion()

1、功能说明

此函数用来返回Trie树中的尾节点即键值最大的实节点。

 

2、函数原型

POSITION MHGetTailPosition(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄，如果Trie树中没有实节点返回值为NULL，否则返回非空

    值。

  

5、相关函数  

MHGetHeadPosition()

MHGetNextPosition()

MHGetPrevPosition()

 

1.  MHGetNext()

1、功能说明

此函数用来返回Trie树中指定实节点的用户数据句柄，同时返回指定实节点的下一个实节点,下一个实节点的键值大于当前实节点的键值,如果当前节点

是最后一个实节点，则返回NULL。

 

2、函数原型

HANDLE MHGetNext(HMHTREE hTree, POSITION& pos);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

    2）POSITION& pos

 指定实节点句柄，输入、输出参数，执行完MHGetNext函数后返回下一个

实节点。

 

4、返回值

    返回输入实节点句柄的用户数据句柄。

  

5、相关函数  

MHGetHeadPosition()

MHGetPrev()

MHGetTailPosition()

 

示例1：

功能：遍历Trie树中节点。

 

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

    char sCarID[19];

    char sName[16];

    char nSex;

    short nAge;

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

 

LPPERSONINFO pPersonInfo;

 

int i;

for(i = 0; i < 10; i++)

{

pPersonInfo = new PERSONINFO;

sprintf(pPersonInfo->sCardID, “12345678901234567%d”, i);

sprintf(pPersonInfo->sName, “zhang%d”, i);

pPersonInfo->nSex = 1;

pPersonInfo->nAge = 20 + i;

POSITION pos;

MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos);

}

 

HANDLE hValue;

POSITION pos;

// 升序遍历

pos = MHGetHeadPosition(hTree);

While(pos != NULL)

{

    hValue = MHGetNext(hTree, pos);

        LPPERSONINFO pPersonInfo;

pPersonInfo = LPPERSONINFO(hValue);

printf(“cardid: %s name: %s sex: %d age: %d\r\n”,

       pPersonInfo->sCardID, pPersonInfo->sName, pPersonInfo->nSex,

            pPersonInfo->nAge);

}

 

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

 

1.  MHGetPrev()

1、功能说明

此函数用来返回Trie树中指定实节点的用户数据句柄，同时返回指定实节点的上一个实节点,上一个实节点的键值小于当前实节点的键值,如果当前节点

是头（第一个）实节点，则返回NULL。

 

2、函数原型

HANDLE MHGetPrev(HMHTREE hTree, POSITION& pos);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

    2）POSITION& pos

 指定实节点句柄，输入、输出参数，执行完MHGetPrev函数后返回上一个

实节点。

 

4、返回值

    返回输入实节点句柄的用户数据句柄。

  

5、相关函数  

MHGetHeadPosition()

MHGetNext()

MHGetTailPosition()

 

示例1：

功能：遍历Trie树中节点。

 

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

    char sCarID[19];

    char sName[16];

    char nSex;

    short nAge;

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

 

LPPERSONINFO pPersonInfo;

 

int i;

for(i = 0; i < 10; i++)

{

pPersonInfo = new PERSONINFO;

sprintf(pPersonInfo->sCardID, “12345678901234567%d”, i);

sprintf(pPersonInfo->sName, “zhang%d”, i);

pPersonInfo->nSex = 1;

pPersonInfo->nAge = 20 + i;

POSITION pos;

MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos);

}

 

HANDLE hValue;

POSITION pos;

 

// 降序遍历

pos = MHGetTailPosition(hTree);

While(pos != NULL)

{

    hValue = MHGetPrev(hTree, pos)

 

        LPPERSONINFO pPersonInfo;

pPersonInfo = LPPERSONINFO(hValue);

printf(“cardid: %s name: %s sex: %d age: %d\r\n”,

       pPersonInfo->sCardID, pPersonInfo->sName, pPersonInfo->nSex,

            pPersonInfo->nAge);

}

 

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

 

 

1.  MHGetFirstPosGEKey()

1、功能说明

此函数返回Trie树中的第一个键值大于等于指定键值的实节点,如果没有满足条件的实节点返回NULL。

 

2、函数原型

POSITION MHGetFirstPosGEKey(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄。

  

5、相关函数  

MHGetFirstPosGTKey()

MHGetFirstPosSEKey()

MHGetFirstPosSTKey()

 

示例1：

 

#include "TrieAPI.h"

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_INT32);

 

int i;

for(i = 0; i < 10; i++)

{

    char sKey[32];

    itoa(i, sKey, 10)

    POSITION pos;

MHAddKey(hTree, sKey, (void *)i, pos);

}

 

POSITION pos;

pos = MHGetFirstPosGEKey(hTree, (void*)(-1)); // 返回键值为0的节点

pos = MHGetFirstPosGEKey(hTree, (void*)0);    // 返回键值为0的节点

pos = MHGetFirstPosGEKey(hTree, (void*)5);    // 返回键值为5的节点

pos = MHGetFirstPosGEKey(hTree, (void*)9);    // 返回键值为9的节点

pos = MHGetFirstPosGEKey(hTree, (void*)10);    // 返回NULL

 

MHDeleteTree(hTree);

 

    return 0;

}

 

1.  MHGetFirstPosGTKey()

1、功能说明

此函数返回Trie树中的第一个键值大于指定键值的实节点,如果没有满足条件的实节点返回NULL。

 

2、函数原型

POSITION MHGetFirstPosGTKey(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄。

  

5、相关函数  

MHGetFirstPosGEKey()

MHGetFirstPosSEKey()

MHGetFirstPosSTKey()

 

示例1：

 

#include "TrieAPI.h"

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_INT32);

 

int i;

for(i = 0; i < 10; i++)

{

    char sKey[32];

    itoa(i, sKey, 10)

    POSITION pos;

MHAddKey(hTree, sKey, (void *)i, pos);

}

 

POSITION pos;

pos = MHGetFirstPosGTKey(hTree, (void*)(-1)); // 返回键值为0的节点

pos = MHGetFirstPosGTKey(hTree, (void*)0);    // 返回键值为1的节点

pos = MHGetFirstPosGTKey(hTree, (void*)5);    // 返回键值为6的节点

pos = MHGetFirstPosGTKey(hTree, (void*)8);    // 返回键值为9的节点

pos = MHGetFirstPosGTKey(hTree, (void*)9);    // 返回NULL

pos = MHGetFirstPosGTKey(hTree, (void*)10);   // 返回NULL

 

MHDeleteTree(hTree);

 

    return 0;

}

 

1.  MHGetFirstPosSEKey()

1、功能说明

此函数返回Trie树中的第一个键值小于等于指定键值的实节点,如果没有满足条件的实节点返回NULL。

 

2、函数原型

POSITION MHGetFirstPosSEKey(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄。

  

5、相关函数  

MHGetFirstPosGTKey()

MHGetFirstPosGEKey()

MHGetFirstPosSTKey()

 

示例1：

 

#include "TrieAPI.h"

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_INT32);

 

int i;

for(i = 0; i < 10; i++)

{

    char sKey[32];

    itoa(i, sKey, 10)

    POSITION pos;

MHAddKey(hTree, sKey, (void *)i, pos);

}

 

POSITION pos;

pos = MHGetFirstPosSEKey(hTree, (void *)(-1)); // 返回NULL

pos = MHGetFirstPosSEKey(hTree, (void *)0);    // 返回键值为0的节点

pos = MHGetFirstPosSEKey(hTree, (void *)5);    // 返回键值为5的节点

pos = MHGetFirstPosSEKey(hTree, (void *)9);    // 返回键值为9的节点

pos = MHGetFirstPosSEKey(hTree, (void *)10);    //返回键值为9的节点

 

MHDeleteTree(hTree);

 

    return 0;

}

 

1.  MHGetFirstPosSTKey()

1、功能说明

此函数返回Trie树中的第一个键值小于指定键值的实节点,如果没有满足条件的实节点返回NULL。

 

2、函数原型

POSITION MHGetFirstPosSEKey(HMHTREE hTree);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

4、返回值

    返回实节点句柄。

  

5、相关函数  

MHGetFirstPosGTKey()

MHGetFirstPosGEKey()

MHGetFirstPosSEKey()

 

示例1：

#include "TrieAPI.h"

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_INT32);

 

int i;

for(i = 0; i < 10; i++)

{

    char sKey[32];

    itoa(i, sKey, 10)

    POSITION pos;

MHAddKey(hTree, sKey, (void *)i, pos);

}

 

POSITION pos;

pos = MHGetPosSTKey(hTree, (void*)(-1)); // 返回NULL

pos = MHGetPosSTKey(hTree, (void*)0);    // 返回NULL

pos = MHGetPosSTKey(hTree, (void*)5);    // 返回键值为4的节点

pos = MHGetPosSTKey(hTree, (void*)9);    // 返回键值为8的节点

pos = MHGetPosSTKey(hTree, (void*)10);    //返回键值为9的节点

 

MHDeleteTree(hTree);

 

    return 0;

}

 

1.  MHGetPosKey()

1、功能说明

此函数用来获取指定实节点的键值。

 

2、函数原型

void MHGetPosKey(POSITION pos, char* sKey);

 

3、参数说明

   1）POSITION pos

      实节点句柄

 

2）char* sKey

 保存返回的键值，注意该指针的空间要足够大，否则会出现内存越界。

    

4、返回值

    无

 

5、相关函数

MHGetNodeValue()

 

示例：                    

参考函数MHGetHeadPosition示例中的关于MHGetPosKey用法。

 

1.  MHGetPosValue()

1、功能说明

此函数用来获取指定节点的用户数据句。

 

2、函数原型

HANDLE MHGetPosValue(POSITION pos);

 

3、参数说明

   1）POSITION pos

      节点句柄。

 

4、返回值

    返回节点的句柄值。

  

5、相关函数  

MHGetPosKey()

 

示例：

参考函数MHGetHeadPosition示例中的关于MHGetPosValue用法。

 

1.  MHSetPosValue()

1、功能说明

此函数用来设置指定实节点的用户数据。

 

2、函数原型

void MHSetPosValue(POSITION pos, HANDLE hValue);

 

3、参数说明

   1）HMHTREE hTree

      Trie树句柄。

 

   2）HANDLE hValue

      设置的用户数据句柄值。

 

4、返回值

    无。

  

5、相关函数  

MHGetPosValue()

 

1.  MHRemoveAt()

1、功能说明

根据实节点句柄删除该节点。

 

2、函数原型

void MHRemoveAt(HMHTREE hTree,POSITION pos);

 

3、参数说明

   1）HMHTREE hTree

      Trie树的句柄，此句柄由MHCreateTree函数生成。

 

2）POSITION pos

  要删除的实节点句柄。

    

4、返回值

    无

 

5、相关函数

 

示例：

功能：根据节点句柄删除节点。

 

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

    char sCarID[19];

    char sName[16];

    char nSex;

    short nAge;

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool OnDelete(POSITION pos, void* pInputPara)

{

LPPERSONINFO pPersonInfo;

pPersonInfo = (LPPERSONINFO)(MHGetPosValue(pos))

 

    delete pPersonInfo;

    return true;

}

 

int main(int argc, char* argv[])

{

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

 

LPPERSONINFO pPersonInfo;

 

int i;

for(i = 0; i < 10; i++)

{

pPersonInfo = new PERSONINFO;

sprintf(pPersonInfo->sCardID, “12345678901234567%d”, i);

sprintf(pPersonInfo->sName, “zhang%d”, i);

pPersonInfo->nSex = 1;

pPersonInfo->nAge = 20 + i;

POSITION pos;

MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos);

}

 

POSITION pos;

pos = MHGetHeadPosition(hTree);

 

MHRemoveAt(pos);

 

MHDeleteTree(hTree, OnDelete, “demo”);

 

    return 0;

}

 

1.  MHSelect()

1、功能说明

此函数用来访问Trie树的一个或多个符合条件的实节点，通过此函数可以通过以下方式访问节点：

 

1、精确访问

   通过提供键值，准确的在Trie树中确定实节点。

 

2、遍历

  通过指定边界，遍历边界内的所有实节点，可以指定升序或降序访问实节点。

 

3、like方式的正向模糊匹配

 根据提供的模糊匹配模式在Trie树中访问符合条件的实节点，可以指定升

序或降序访问实节点。

 

4、前缀匹配

Trie树中保存前缀集合，通过指定键值在树中搜索符合条件的前缀，可以

指定精度递增或递减。

 

2、函数原型

void MHSelect(LPQUERYCOND pCond);

 

3、参数说明

  LPQUERYCOND pCond。

     结构体LPQUERYCOND定义如下：

 

    typedef struct _QUERYCOND

{      

        HMHTREE hTree;     

        bool bEnableTop;   

        int nTopCount; 

        char* sIndexValue; 

        bool bEnableLower; 

        bool bIncludeLower;

        char* sLowerValue; 

        bool bEnableUpper; 

        bool bIncludeUpper;

        char* sUpperValue; 

        int nMethod;

        bool bAsc;     

       

        ONMHSELECT pFilterAPI;

        void* pFilterPara; 

 

        int nTopCounted;   

        POSITION pos;

        …………………

}QUERYCOND;

   

    下面介绍结构体成员的定义：

1. HMHTREE hTree

Trie树的句柄

 

    2）int nMethod;

       指明各级树的访问方法

 

1. TRIE_METHOD_ITERATE

用遍历的方式访问Trie树。

 

1. TRIE_METHOD_KEY

用键值精确匹配方式访问Trie树。

 

1. TRIE_METHOD_MATCH

用键值匹配规则表达式的方式访问Trie树。

 

1. TRIE_METHOD_LIKE

用规则表达式的匹配节点主键的方式访问Trie树。

 

    3）char* sIndexValue;

       此变量为查询需要的键值，此成员变量在访问方式为：

TRIE_METHOD_KEY、TRIE_METHOD_MATCH、TRIE_METHOD_LIKE时必须填写

值,对于TRIE_METHOD_ITERATE遍历方式不起作用。

 

    4）bool bEnableLower;

此变量在访问方式为TRIE_METHOD_ITERATE遍历时起作用,指明在遍历

时是否启用最小值。

true: 启用最小值，同时必须设置变量bIncludeLower和sLowerValue

false: 不启用最小值，遍历时最小值为头节点（包括头节点）

 

    5）char* sLowerValue;

       此变量只对访问方式TRIE_METHOD_ITERATE遍历方式起作用,且

bEnableLower设置为true, 指定遍历的最小值。

 

    6）bool bIncludeLower;

       此变量只对访问方式TRIE_METHOD_ITERATE遍历方式起作用,且

bEnableLower设置为true, 指定遍历时是否访问指定的最小值（sLowerValue）实节点。

 

    7）bool bEnableUpper;

此变量在访问方式为TRIE_METHOD_ITERATE遍历时起作用,指明在遍历

时是否启用最大值。

true: 启用最大值，同时必须设置变量bIncludeUpper和sUpperValue

false: 不启用最大值，遍历时最大值为尾节点（包括尾节点）

 

    8）char* sLowerValue;

       此变量只对访问方式TRIE_METHOD_ITERATE遍历方式起作用,且

bEnableUpper设置为true, 指定遍历的最大值。

 

    9）bool bIncludeUpper;

       此变量只对访问方式TRIE_METHOD_ITERATE遍历方式起作用,且

bEnableUpper设置为true, 指定遍历时是否访问指定的最大值（sUpperValue）实节点。

 

    10）bool bAsc;

       此变量指明访问符合条件实节点的顺序（升、降），此成员变量在访问方

式为：RTDB_METHOD_ITERATE、RTDB_METHOD_LIKE时按照值的大小；在访

问方式为：RTDB_METHOD_MATCH时为匹配精度；对于RTDB_METHOD_KEY

遍历方式不起作用。

 

    11）bool bEnableTop;

       该成员变量指明是否启用限制最大访问实节点数量。

       false：关闭该功能

       true：启用该功能

 

    12）int nTopCount;

       该变量指明访问符合条件实节点最大的数量，当访问符合条件的节点达

到nTopCount时MHSelect函数返回。

 

    13）FILTERAPI pFilterAPI;

       此变量为回调函数指针，当MHSelect函数访问到符合搜索条件的实节点

时就会自动调用此函数，开发人员在回调函数中对当前节点进行处理。

回调函数的定义形式如下：

typedef bool (*ONMHSELECT)(_QUERYCOND* pCondition);

参数：

_SELECTCOND* pCondition

 

返回值：

1）true

    指示MHSelect函数继续访问符合条件的节点。

 

2）false

    指示MHSelect函数停止访问符合条件的节点,函数返回。

 

14）void* pFilterPara;

由开发人员设置自己的数据，一般为结构体或对象的指针，由回调函数

使用。

 

    15）int nTopCounted;

此变量保存已经访问符合条件的数据节点,用户只能读此变量,不能修改

此变量。

 

    16）POSITION hPos;

此变量保存当前访问的实节点句柄,

（1）通过调用MHGetCurrentKey函数可返回此实节点的键值。

（2）通过调用MHGetCurrentValue函数获取当前实节点的值。

（3）通过调用MHGetCurrentPosition函数可返回此变量。

 

4、返回值

    无

 

5、相关函数

MHGetCurrentPosition()

MHGetCurrentKey()

MHGetCurrentValue()

 

注意：

不允许在回调函数中增加和删除数据节点,如果需要可以在回调函数中把信息输出到pFilterPara中，在执行完MHSelect函数后再进一步处理。

1.  MHGetCurrentPosition()

1、功能说明

此函数由MHSelect中的pFilterAPI的回调函数调用，用来获取当前实节点句柄。

 

2、函数原型

POSITION MHGetCurrentPosition(LPQUERYCOND pCond);

 

3、参数说明

   1）LPQUERYCOND pCond

      此指针来自回调函数的参数值。

    

4、返回值

    实节点句柄

   

5、相关函数

MHSelect()

MHGetCurrentKey()

MHGetCurrentValue()

 

1.  MHGetCurrentKey()

1、功能说明

获取当前MHSelect函数访问实节点的键值。

 

2、函数原型

void MHGetCurrentKey(LPQUERYCOND pCond, char* sKey);

 

3、参数说明

   1）LPSELECTCOND hSelectCond

      此指针来自回调函数的参数值。

 

2）char* sKey

 保存返回的键值，空间由调用方在外部分配，注意空间要足够大，避免出

现越界错误。

    

4、返回值

    无

 

5、相关函数

MHSelect()

MHGetCurrentPosition()

MHGetCurrentValue()

 

1.  MHGetCurrentValue()

1、功能说明

获取当前访问的实节点的句柄值。

 

2、函数原型

HANDLE MHGetCurrentKey(LPQUERYCOND pCond);

 

3、参数说明

   1）LPQUERYCOND hCond

      此指针来自回调函数的参数值。

    

4、返回值

    无

 

5、相关函数

MHSelect()

MHGetCurrentPosition()

MHGetCurrentValue()

 

1.  MHSelect函数用例
2.  遍历-1

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LPQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);      

       printf(“CardID: %s\r\n”, pRetInfo->sCardID);

 

return true;

}                                        

 

int AccessSingle(HANDLE hTree, bool bAsc, bool bTopEnable, int nTopCount)

{   

QUERYCOND pCond;

   

pCond.hTree = hTree;

pCond.nMethod = TRIE_METHOD_ITERATE;

pCond.bAsc = bAsc;

pCond.bEnableTop = bTopEnable;

pCond.bEnableLower = false;

pCond.bEnableUpper = false;

pCond.nTopCount = nTopCount;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;               

 

MHSelect(&pCond);                  

 

return 0;

}

      

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       // 以升序方式打印所有数据节点

       AccessSingle(hTree, true, false, 0);

 

    // 以升序方式打印前3个数据节点

       AccessSingle(hTree, true, true, 3);

 

    // 以升序方式打印所有数据节点

       AccessSingle(hTree, false, false, 0);

 

    // 以升序方式打印前3个数据节点

       AccessSingle(hTree, false, true, 3);

 

       MHDeleteTree(hTree);

 

    return 0;

}

1.  遍历-2

#include "TrieAPI.h"

#include <stdio.h>

#include <stdlib.h>

 

bool OnSelect(LPQUERYCOND pCond)

{

       POSITION pos;

       pos = MHGetCurrentPosition(pCond);

      

       HANDLE hValue;

       hValue = MHGetPosValue(pos);

      

       char sKey[256];

       MHGetPosKey(pos, sKey);

      

       printf("key: %s value: %d\r\n", sKey, int(hValue));

      

       return true;

}

 

int main(int argc, char* argv[])

{

       HMHTREE hTree;

       hTree = MHCreateTree(TRIE_INT32);

      

       int i;

       for (i = -10; i <= 10; i++)

       {

              char str[32];

              itoa(i, str, 10);

              POSITION pos;

              MHAddKey(hTree, str, (void *)i, pos);

              i++;

       }

             

       QUERYCOND pCond;

       // 升序遍历 < -5的所有节点

       pCond.hTree = hTree;

       pCond.nMethod = TRIE_METHOD_ITERATE;               

       pCond.bEnableLower = false;

       pCond.bEnableUpper = true;

       pCond.bIncludeUpper = false;

       pCond.sUpperValue = "-5";

       pCond.bAsc = true;

       pCond.pFilterAPI = OnSelect;

       pCond.pFilterPara = "1234567890";

      

       MHSelect(&pCond);

      

       printf("\r\n");

 

       // 降序遍历 < -5的所有节点

       pCond.hTree = hTree;

       pCond.nMethod = TRIE_METHOD_ITERATE;                      

       pCond.bEnableLower = true;

       pCond.bIncludeLower = false;

       pCond.sLowerValue = "-5";

       pCond.bEnableUpper = false;

       pCond.bAsc = true;

       pCond.pFilterAPI = OnSelect;

       pCond.pFilterPara = "1234567890";

      

       MHSelect(&pCond);

 

       printf("\r\n");

      

       // 升序遍历 >= -6 && <= 6的所有节点

       pCond.hTree = hTree;

       pCond.nMethod = TRIE_METHOD_ITERATE;                      

       pCond.bEnableLower = true;

       pCond.bIncludeLower = true;

       pCond.sLowerValue = "-6";

       pCond.bEnableUpper = true;

       pCond.bIncludeUpper = true;

       pCond.sUpperValue = "6";

       pCond.bAsc = true;

       pCond.pFilterAPI = OnSelect;

       pCond.pFilterPara = "1234567890";

      

       MHSelect(&pCond);

      

       MHDeleteTree(hTree);               

             

       return 0;

}

 

1.  精确查询

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail [128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

int AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LPQUERYCOND pCond)

{  

HANDLE hHandle;

hValue = MHGetCurrentValue(pCond);

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hRetValue);  

 

       printf(“CardID: %s”, pRetInfo->sCardID);

printf(“Sex: %d”, pRetInfo->nSex);

printf(“Name: %s”, pRetInfo->sName);

printf(“Age: %d”, pRetInfo->nAge);

printf(“Address: %s”, pRetInfo->sAddress);

printf(“Email: %s\r\n”, pRetInfo->sEmail);

 

return true;

}                                        

 

int AccessSingle(HANDLE hTree, char* sKey)

{   

QUERYCOND pCond;

   

pCond.hTree = hTree;

pCond.nMethod[0] = TRIE_METHOD_KEY;

pCond.sIndexValue = sKey;        

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;               

 

MHSelect(&pCond);                    

 

return;

}

      

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       AccessSingle(hTree, ” 123456789012345670”);

 

       MHDeleteTree(hTree); 

 

    return 0;

}

1.  反向模糊匹配（前缀匹配）

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PREFIXINFO

{

       char sPrefix[32];

char sData[32];

} PREFIXINFO;

typedef PREFIXINFO * LPPREFIXINFO;

 

bool AddPrefixInfo(HANDLE hTree, char* sPrefix, char* sData)

{    

       LPPREFIXINFO pPrefixInfo;

       pPrefixInfo = new PREFIXINFO;

 

       strcpy(pPrefixInfo->sPrefix, sPrefix);

strcpy(pPrefixInfo->sData, sData);

 

       POSITION pos;

       return(MHAddKey(hTree, sPrefix, pPrefixInfo, pos));

}

 

bool FilterProc(LPQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);

 

LPPREFIXINFO pRetInfo;

       pRetInfo = LPPREFIXINFO (hValue);      

       printf(“Prefix: %s”, pRetInfo-> sPrefix);

 

return true;

}                                        

 

int AccessSingle(HANDLE hTree, char* sKey, bool bTopEnable, int nTopCount)

{   

QUERYCOND pCond;

   

pCond.hTree = hTree;        

pCond.nMethod = TRIE_METHOD_MATCH;

pCond.sIndexValue = sKey;        

pCond.bAsc = false;

pCond.bEnableTop = bTopEnable;

pCond.nTopCount = nTopCount;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;                 

 

MHSelect(&pSelectCond);              

 

return 0;

}

      

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPrefixInfo(hTree, “%”, “0”);

AddPrefixInfo(hTree, “1%”, “1”);

AddPrefixInfo(hTree, “12%”, “12”);

AddPrefixInfo(hTree, “123%”, “123”);

AddPrefixInfo(hTree, “1234%”, “1234”);

AddPrefixInfo(hTree, “12345%”, “12345”);

AddPrefixInfo(hTree, “123456%”, “123456”);

AddPrefixInfo(hTree, “1234567%”, “1234567”);

AddPrefixInfo(hTree, “12345678%”, “12345678”);

AddPrefixInfo(hTree, “123456789%”, “123456789”);

 

       AccessSingle(hTree, “1234567890”, false, 0);

    // 依次输出以下节点

    /*

    123456789%

12345678%

1234567%

123456%

12345%

1234%

123%

12%

 

1%

%

*/

 

    AccessSingle(hTree, “1234500000000”, false, 0);

    // 依次输出以下节点

    /*

12345%

1234%

123%

12%

 

1%

%

*/

 

       MatchSingle(hTree, “12345%”, true, 3);

       // 依次输出以下节点

    /*

12345%

1234%

123%

       */

 

       MHDeleteTree(hTree); 

 

    return 0;

}

 

1.  正向模糊匹配(like)

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LPQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);    

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);      

       printf(“CardID: %s\r\n”, pRetInfo->sCardID);

 

return true;

}                                        

 

int AccessSingle(HANDLE hTree, char* sKey, bool bAsc, bool bTopEnable,

int nTopCount)

{   

QUERYCOND pCond;

   

pCond.hTree = hTree;

pCond.nMethod = TRIE_METHOD_LIKE;

pCond.sIndexValue = sKey;        

pCond.bAsc = bAsc;

pCond.bEnableTop = bTopEnable;

pCond.nTopCount = nTopCount;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;                 

 

MHSelect(&pCond);                  

 

return 0;

}

      

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       // 以升序方式打印所有数据节点

       AccessSingle(hTree, “1234567890%”, true, false, 0);

 

    // 以升序方式打印前3个数据节点

       AccessSingle(hTree, “12345678901234567?”, true, true, 3);

 

       // 以降序方式打印所有数据节点

       AccessSingle(hTree, “1234567890%”, false, false, 0);

 

    // 以降序方式打印前3个数据节点

       AccessSingle(hTree, “12345678901234567?”, false, true, 3);

 

       MHDeleteTree(hTree); 

 

    return 0;

}

1.  回调函数
2.  获取当前实节点信息

1、功能说明

    在回调函数中调用相关函数获取当前节点的信息。

 

2、相关函数

MHGetNodeValue()

 

示例：                    

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);      

       printf(“CardID: %s\r\n”, pRetInfo->sCardID);

 

POSITION pos;

pos  = MHGetCurrentPosition(pCond);

 

hValue = MHGetPosValue(pCond);

pRetInfo = LPPERSONINFO(hValue);      

printf(“CardID: %s\r\n”, pRetInfo->sCardID);

 

char sKey[256];

// 获取当前实节点对应的键值

MHGetCurrentKey(pCond, sKey);

printf(“Key: %s\r\n”, sKey);

 

return true;

}                                        

 

int AccessSingle(HANDLE hTree, bool bAsc, bool bTopEnable, int nTopCount)

{   

QUERYCOND pCond;

   

pCond.hTree = hTree;

pCond.nMethod = TRIE_METHOD_ITERATE;

pCond.bAsc = bAsc;

pCond.bEnableTop = bTopEnable;

pCond.bEnableLower = false;

pCond.bEnableUpper = false;

pCond.nTopCount = nTopCount;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;               

 

MHSelect(&pSelectCond);            

 

return 0;

}

      

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       // 以升序方式打印所有数据节点

       AccessSingle(hTree, true, false, 0);

 

    // 以升序方式打印前3个数据节点

       AccessSingle(hTree, true, true, 3);

 

    // 以升序方式打印所有数据节点

       AccessSingle(hTree, false, false, 0);

 

    // 以升序方式打印前3个数据节点

       AccessSingle(hTree, false, true, 3);

 

       MHDeleteTree(hTree);

 

    return 0;

}

1.  在回调函数中控制MHSelect返回

回调函数定义如下：

typedef bool (*FILTERAPI)(_QUERYCOND* pCond);

 

当执行回调函数时，如果返回false，则MHSelect函数结束执行。

 

示例：

在完整遍历trie树的过程中，在满足指定条件下结束遍历。

 

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);      

       printf(“CardID: %s\r\n”, pRetInfo->sCardID);         

 

if(strcmp(pRetInfo->sCardID, “123456789012345675”) == 0)

{   // 当满足此条件时，结束 MHSelect函数的运行

    return false;

}

 

return true;

}                                        

 

int main(int nArgc, char* sArgv[])

{    

HMHTREE hTree;

hTree = MHCreateTree(TRIE_STRING);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       // 以升序方式打印所有数据节点

QUERYCOND pCond;

   

pCond.hTree = hTree;

pCond.nMethod = TRIE_METHOD_ITERATE;

pCond.bAsc = true;

pCond.bEnableLower = false;

pCond.bEnableUpper = false;

pCond.bEnableTop = bTopEnable;

pCond.nTopCount = nTopCount;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = NULL;                  

 

MHSelect(&pCond);

 

MHDeleteTree(hTree);

 

    return 0;

}

 

1.  在回调函数中使用参数

#include <stdio.h>

#include "TrieAPI.h"

 

typedef struct _PERSONINFO

{

       char sCardID[19];

    int nSex;

       char sName[32];

       int nAge;

char sAddress[128];

char sEmail[128];

}PERSONINFO;

typedef PERSONINFO* LPPERSONINFO;

 

bool AddPersonInfo(HANDLE hTree,char* sCardID, int nSex, char* sName, int nAge,

char* sAddress, char* sEmail)

{    

       LPPERSONINFO pPersonInfo;

       pPersonInfo = new PERSONINFO;

 

       strcpy(pPersonInfo->sCardID, sCardID);

pPersonInfo->nSex = nSex;

strcpy(pPersonInfo->sName, sName);

pPersonInfo->nAge = nAge;

strcpy(pPersonInfo->sAddress, sAddress);

       strcpy(pPersonInfo->sEmail, sEmail);

 

POSITION pos;

       return(MHAddKey(hTree, pPersonInfo->sCardID, pPersonInfo, pos));

}

 

bool FilterProc(LPQUERYCOND pCond)

{  

HANDLE hValue;

hValue = MHGetCurrentValue(pCond);

 

LPPERSONINFO pRetInfo;

       pRetInfo = LPPERSONINFO(hValue);      

      

FILE* fp;

       fp = (FILE *)(pCond->pFilterPara);

fprintf(fp,"%s,%d,%s,%d,%s,%s\r\n",pRetInfo->sCardID,pRetInfo->nSex,

pRetInfo->sName, pRetInfo->nAge, pRetInfo->sAddress, pRetInfo->sEmail);

 

return true;

}                                        

 

int main(int nArgc, char* sArgv[])

{    

   

    hTree = HTreeCreate(&TreeDesc);

      

       AddPersonInfo(hTree, “123456789012345670”, 1, “张零”, 20,

“广东省深圳市龙岗区0栋”, “zhang0@cacheserver.com.cn”);

       AddPersonInfo(hTree, “123456789012345671”, 1, “张一”, 21,

“广东省深圳市龙岗区1栋”, “zhang1@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345672”, 1, “张二”, 22,

“广东省深圳市龙岗区2栋”, “zhang2@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345673”, 1, “张三”, 23,

“广东省深圳市龙岗区3栋”, “zhang3@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345674”, 1, “张四”, 24,

“广东省深圳市龙岗区4栋”, “zhang4@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345675”, 1, “张五”, 25,

“广东省深圳市龙岗区5栋”, “zhang5@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345676”, 1, “张六”, 26,

“广东省深圳市龙岗区6栋”, “zhang6@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345677”, 1, “张七”, 27,

“广东省深圳市龙岗区7栋”, “zhang7@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345678”, 1, “张八”, 28,

“广东省深圳市龙岗区8栋”, “zhang8@cacheserver.com.cn”);

AddPersonInfo(hTree, “123456789012345679”, 1, “张九”, 29,

“广东省深圳市龙岗区9栋”, “zhang9@cacheserver.com.cn”);

 

       FILE* fp;

       fp = fopen("c:\\PersonInfo.txt", "w+b");

       if(fp == NULL)

       {

              return 0; 

       }

      

QUERYCOND pCond;   

pCond.hTree = hTree;

pCond.nMethod = TRIE_METHOD_ITERATE;

pCond.bAsc =true;

pCond.bEnableLower = false;

pCond.bEnableUpper = false;

pCond.bEnableTop = false;

pCond.pFilterAPI = FilterProc;

pCond.pFilterPara = fp;

 

MHSelect(&pCond);                  

   

       fclose(fp);

 

MHDeleteTree(hTree);

 

    return 0;

}