字典c语言,字典树 -c语言

字典树 --c语言

(1)trie.h

#ifndef TRIE_H_

#define TRIE_H_

typedef struct word_trie_t word_trie_t;

typedef enum bool bool;

enum bool

{

false=0,

true=1,

};

struct word_trie_t

{

bool (*insert)(word_trie_t *this,char *str);

bool (*find_word)(word_trie_t *this,char *str);

int (*find_prefix)(word_trie_t *this,char *str);

bool (*delete)(word_trie_t *this,char *str);

void (*destroy)(word_trie_t *this);

};

word_trie_t *word_trie_create();

#endif

(2)trie.c

#include "trie.h"

#include

#include

#include

//

/* 字典树节点 */

//

#define TRIE_NODE_MAX 26

typedef struct trie_node_t trie_node_t;

/*字典树节点结构*/

struct trie_node_t

{

int count; //用来计算前缀数

bool is_str; //用来标识到此的字符串

trie_node_t *word[TRIE_NODE_MAX]; //子节点指针

};

/*创建一个节点*/

trie_node_t* trie_node_create()

{

trie_node_t* node=(trie_node_t *)malloc(sizeof(trie_node_t));

memset(node,0,sizeof(trie_node_t));

return node;

}

/*回收一个节点*/

void trie_node_destroy(trie_node_t* node)

{

free(node);

}

///

/* 字典树对外接口实现 */

///

typedef struct private_word_trie_t private_word_trie_t;

struct private_word_trie_t

{

word_trie_t public; //对外接口

trie_node_t *root; //字典树根

};

//插入一个字符串

bool insert(private_word_trie_t *this,char *str)

{

trie_node_t *current=this->root;

int word_pos;

//不断的循环插入，直到字符串结尾

while(*str)

{

word_pos=*str-'a';

//如果插入的分支为空，新建节点

if(current->word[word_pos]==NULL)

{

current->word[word_pos]=trie_node_create();

}

current=current->word[word_pos];

//节点索引值增加

current->count++;

str++;

}

//在最后一个节点标识为一个字符串

current->is_str=true;

return true;

}

//查找节点

bool find_word(private_word_trie_t *this,char *str)

{

trie_node_t *current=this->root;

int word_pos;

while(*str)

{

word_pos=*str-'a';

//如果分支为空，标识没有此字符串

if((current=current->word[word_pos])==NULL)

{

return false;

}

str++;

}

return current->is_str;

}

//查找前缀数

int find_prefix(private_word_trie_t *this,char *str)

{

trie_node_t *current=this->root;

int word_pos;

while(*str)

{

word_pos=*str-'a';

if((current=current->word[word_pos])==NULL)

{

return 0;

}

str++;

}

return current->count;

}

//删除一个字符串

bool delete(private_word_trie_t *this,char *str)

{

trie_node_t *current=this->root;

int word_pos;

trie_node_t *del=NULL;

//第一步查找，如果是曾经插入的字符串，可以删除

if(find_word(this,str))

{

//释放前缀数，如果索引值为0，可以回收节点

while(*str)

{

word_pos=*str-'a';

if(((current->word[word_pos])->count--)==0)

{

del=current->word[word_pos];

current->word[word_pos]=NULL;

str++;

break;

}

str++;

}

//释放下面的节点

if(del!=NULL)

{

while(*str)

{

word_pos=*str-'a';

current=del;

del=current->word[word_pos];

trie_node_destroy(current);

str++;

}

trie_node_destroy(del);

}

return true;

}

else

{

return false;

}

}

//递归回收节点

void trie_destroy(trie_node_t *node)

{

int i;

for(i=0;i

{

if(node->word[i]!=NULL)

{

trie_destroy(node->word[i]);

}

}

trie_node_destroy(node);

}

//销毁节点树

void destroy(private_word_trie_t *this)

{

trie_destroy(this->root);

free(this);

}

//创建字典树对象

word_trie_t *word_trie_create()

{

private_word_trie_t *this=(private_word_trie_t *)malloc(sizeof(private_word_trie_t));

this->public.insert=(bool (*)(word_trie_t *,char *))insert;

this->public.find_word=(bool (*)(word_trie_t *,char *))find_word;

this->public.find_prefix=(int (*)(word_trie_t *,char *))find_prefix;

this->public.delete=(bool (*)(word_trie_t *,char *))delete;

this->public.destroy=(void (*)(word_trie_t *))destroy;

this->root=trie_node_create();

return &this->public;

}

int main()

{

word_trie_t *tree=word_trie_create();

char str[100];

while(gets(str)&&str[0])

{

tree->insert(tree,str);

}

while(gets(str)&&str[0])

{

printf("前缀:%d\n",tree->find_prefix(tree,str));

if(tree->find_word(tree,str))

{

printf("%s是插入的一个字符串\n",str);

}

else

{

printf("%s不是插入的一个字符串\n",str);

}

}

tree->destroy(tree);

return 1;

}