数据结构——键树之Tire树
#include
"
stdio.h
"
#include
"
stdlib.h
"
#include
"
string.h
"
#include
"
ctype.h
"
#define
OK 1
#define
ERROR 0
typedef
int
Status;
//
Status是函数的类型,其值是函数结果状态代码，如OK等
typedef
int
Boolean;
//
Boolean是布尔类型,其值是TRUE或false
#define
N 16
//
数据元素个数
#define
MAXKEYLEN 16
//
关键字的最大长度
#define
STACK_INIT_SIZE 10
//
存储空间初始分配量
#define
STACKINCREMENT 2
//
存储空间分配增量
#define
LENGTH 27
//
结点的最大度+1(大写英文字母)
#define
Nil ' '
//
定义结束符为空格
#define
MAXKEYLEN 16
//
关键字的最大长度
#define
EQ(a,b) (!strcmp((a),(b)))
#define
LT(a,b) (strcmp((a),(b))<0)
#define
LQ(a,b) (strcmp((a),(b))<=0)
struct
Others
//
记录的其它部分
{
int
ord;
};
struct
KeysType
//
关键字类型
{
char
ch[MAXKEYLEN];
//
关键字
int
num;
//
关键字长度
};
struct
Record
//
记录类型
{
KeysType key;
//
关键字
Others others;
//
其它部分(由主程定义)
};
enum
NodeKind{LEAF,BRANCH};
//
结点种类:{叶子,分支}
typedef
struct
TrieNode
//
Trie键树类型
{
NodeKind kind;
union
{
struct
//
叶子结点
{
KeysType K;
Record
*
infoptr;
}lf;
struct
//
分支结点
{
TrieNode
*
ptr[LENGTH];
//
LENGTH为结点的最大度+1,在主程定义
//
int num; 改
}bh;
};
//
union
}TrieNode,
*
TrieTree;
//
对两个字符串型关键字的比较约定为如下的宏定义
Status InitDSTable(TrieTree
&
T)
{
//
操作结果: 构造一个空的Trie键树T
T
=
NULL;
return
OK;
}
void
DestroyDSTable(TrieTree
&
T)
{
//
初始条件: Trie树T存在。操作结果: 销毁Trie树T
int
i;
if
(T)
//
非空树
{
for
(i
=
0
;i
<
LENGTH;i
++
)
{
if
(T
->
kind
==
BRANCH
&&
T
->
bh.ptr[i])
//
第i个结点不空
{
if
(T
->
bh.ptr[i]
->
kind
==
BRANCH)
//
是子树
{
DestroyDSTable(T
->
bh.ptr[i]);
}
else
//
是叶子
{
free(T
->
bh.ptr[i]);
T
->
bh.ptr[i]
=
NULL;
}
}
}
//
for
free(T);
//
释放根结点
T
=
NULL;
//
空指针赋0
}
//
if(T)
}
//
DestroyDSTable
Status pr(Record
*
r)
{
printf(
"
(%s,%d)
"
,r
->
key.ch,r
->
others.ord);
return
OK;
}
//
pr
int
ord(
char
c)
{
c
=
toupper(c);
if
(c
>=
'
A
'
&&
c
<=
'
Z
'
)
return
c
-
'
A
'
+
1
;
//
英文字母返回其在字母表中的序号
else
return
0
;
//
其余字符返回0
}
//
ord
Record
*
SearchTrie(TrieTree T,KeysType K)
{
//
在键树T中查找关键字等于K的记录
TrieTree p;
int
i;
for
(p
=
T,i
=
0
; p
&&
p
->
kind
==
BRANCH
&&
i
<
K.num; p
=
p
->
bh.ptr[ord(K.ch[i])],
++
i )
;
//
对K的每个字符逐个查找,*p为分支结点,ord()求字符在字母表中序号
if
(p
&&
p
->
kind
==
LEAF
&&
p
->
lf.K.num
==
K.num
&&
EQ(p
->
lf.K.ch,K.ch))
//
查找成功
return
p
->
lf.infoptr;
else
//
查找不成功
return
NULL;
}
//
SearchTrie
void
InsertTrie(TrieTree
&
T,Record
*
r)
{
//
初始条件: Trie键树T存在，r为待插入的数据元素的指针
//
操作结果: 若T中不存在其关键字等于(*r).key.ch的数据元素，
//
则按关键字顺序插r到T中
TrieTree p,q,ap;
int
i
=
0
,j;
KeysType K1,K
=
r
->
key;
if
(
!
T)
//
空树
{
T
=
(TrieTree)malloc(
sizeof
(TrieNode));
//
新建根节点
T
->
kind
=
BRANCH;
for
(i
=
0
;i
<
LENGTH;i
++
)
//
初始化，指针量赋初值NULL
T
->
bh.ptr[i]
=
NULL;
p
=
T
->
bh.ptr[ord(K.ch[
0
])]
=
(TrieTree)malloc(
sizeof
(TrieNode));
//
新建叶子节点
p
->
kind
=
LEAF;
p
->
lf.K
=
K;
p
->
lf.infoptr
=
r;
}
//
if
else
//
非空树
{
for
(p
=
T,i
=
0
; p
&&
p
->
kind
==
BRANCH
&&
i
<
K.num;
++
i)
{
q
=
p;
p
=
p
->
bh.ptr[ord(K.ch[i])];
}
//
for
i
--
;
if
(p
&&
p
->
kind
==
LEAF
&&
p
->
lf.K.num
==
K.num
&&
EQ(p
->
lf.K.ch,K.ch))
//
T中存在该关键字
return
;
else
//
T中不存在该关键字,插入之
{
if
(
!
p)
//
分支空，建立叶子节点，指向关键字记录
{
p
=
q
->
bh.ptr[ord(K.ch[i])]
=
(TrieTree)malloc(
sizeof
(TrieNode));
p
->
kind
=
LEAF;
p
->
lf.K
=
K;
p
->
lf.infoptr
=
r;
}
//
if
else
if
(p
->
kind
==
LEAF)
//
有不完全相同的叶子，
{
K1
=
p
->
lf.K;
do
{
ap
=
q
->
bh.ptr[ord(K.ch[i])]
=
(TrieTree)malloc(
sizeof
(TrieNode));
ap
->
kind
=
BRANCH;
for
(j
=
0
;j
<
LENGTH;j
++
)
//
指针量赋初值NULL
ap
->
bh.ptr[j]
=
NULL;
q
=
ap;
i
++
;
}
while
( ord(K.ch[i])
==
ord(K1.ch[i]) );
//
do...while
//
如果原来的记录和新插入的关键字的第i个字符还是相等的话就再新生一个分支,
//
直到不相等时，把原来的记录重新连到这个分支上，再新建一个叶子节点指向新插入的关键字
q
->
bh.ptr[ord(K1.ch[i])]
=
p;
//
把原来的不相同的叶子挂回来，如果是空字符，就挂在0号指针下
p
=
q
->
bh.ptr[ord(K.ch[i])]
=
(TrieTree)malloc(
sizeof
(TrieNode));
p
->
kind
=
LEAF;
p
->
lf.K
=
K;
p
->
lf.infoptr
=
r;
}
//
else if
}
//
else
}
//
else
}
//
InsertTrie
void
InputD(TrieTree
&
t,Record r[])
{
Record
*
p;
for
(
int
i
=
0
;i
<
N;i
++
)
{
r[i].key.num
=
strlen(r[i].key.ch)
+
1
;
r[i].key.ch[r[i].key.num]
=
Nil;
//
在关键字符串最后加结束符
p
=
SearchTrie(t,r[i].key);
if
(
!
p)
InsertTrie(t,
&
r[i]);
}
//
for
}
//
InputD
void
TraverseDSTable(TrieTree T,Status(
*
Vi)(Record
*
))
{
//
初始条件: Trie键树T存在，Vi是对记录指针操作的应用函数
//
操作结果: 按关键字的顺序输出关键字及其对应的记录
TrieTree p;
int
i;
if
(T)
{
for
(i
=
0
;i
<
LENGTH;i
++
)
{
p
=
T
->
bh.ptr[i];
if
(p
&&
p
->
kind
==
LEAF)
Vi(p
->
lf.infoptr);
else
if
(p
&&
p
->
kind
==
BRANCH)
TraverseDSTable(p,Vi);
}
//
for
}
//
if
printf(
"
\n
"
);
}
//
TraverseDSTable
void
UserSearch(TrieTree t)
{
char
s[MAXKEYLEN
+
1
];
KeysType k;
Record
*
p;
printf(
"
\n请输入待查找记录的关键字符串:
"
);
scanf(
"
%s
"
,s);
k.num
=
strlen(s)
+
1
;
strcpy(k.ch,s);
k.ch[k.num]
=
Nil;
//
在关键字符串最后加结束符
p
=
SearchTrie(t,k);
if
(p)
pr(p);
else
printf(
"
没找到
"
);
printf(
"
\n
"
);
}
//
UserSearch
int
main()
{
TrieTree t;
Record r[N]
=
{{{
"
CAI
"
},
1
},{{
"
CAO
"
},
2
},{{
"
LI
"
},
3
},{{
"
LAN
"
},
4
},
{{
"
CHA
"
},
5
},{{
"
CHANG
"
},
6
},{{
"
WEN
"
},
7
},{{
"
CHAO
"
},
8
},
{{
"
YUN
"
},
9
},{{
"
YANG
"
},
10
},{{
"
LONG
"
},
11
},{{
"
WANG
"
},
12
},
{{
"
ZHAO
"
},
13
},{{
"
LIU
"
},
14
},{{
"
WU
"
},
15
},{{
"
CHEN
"
},
16
}};
InitDSTable(t);
InputD(t,r);
printf(
"
按关键字符串的顺序遍历Trie树(键树):\n
"
);
TraverseDSTable(t,pr);
UserSearch(t);
DestroyDSTable(t);
return
1
;
}