双链键树的实现（第九章 P248 算法9.15）

最新推荐文章于 2020-12-04 16:43:08 发布
最新推荐文章于 2020-12-04 16:43:08 发布
阅读量257 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42185999/article/details/105496785
版权

键树

又称为数字查找树，它是一棵度 >= 2的树，同以往所学习的树不同的是，键树的结点中存储的不是某个关键字，而是只含有组成关键字的单个符号。

如果关键字本身是字符串，则键树中的一个结点只包含有一个字符；如果关键字本身是数字，则键树中的一个结点只包含一个数位。每个关键字都是从键树的根结点到叶子结点中经过的所有结点中存储的组合。

例如，当使用键树表示查找表{CAI，CAO，CHEN，LI，LAN，ZHAO}时，为了查找方便，首先对该查找表中关键字按照首字符进行分类（相同的在一起）：

{{CAI,CAO,CHEN},{LI,LAN},{ZHAO}}

然后继续分割，按照第二个字符、第三个字符、...，最终得到的查找表为：

{{CAI,CAO},{CHEN},{LI,LAN},{ZHAO}}

然后使用键树结构表示该查找表，如下图 所示：


 

注意：键树中叶子结点的特殊符号 $ 为结束符，表示字符串的结束。使用键树表示查找表时，为了方便后期的查找和插入操作，约定键树是有序树（兄弟结点之间自左至右有序），同时约定结束符 ‘$’ 小于任何字符。

 

 

键树的存储结构

 

键树的存储结构有两种：一种是通过使用树的孩子兄弟表示法来表示键树，即双链树；另一种是以树的多重链表表示键树，即Trie 树，又称字典树。

 

双链树

当使用孩子兄弟表示法表示键树时，树的结点构成分为3部分：

  • symbol域：存储关键字的一个字符；
  • first域：存储指向孩子结点的指针；
  • next域：存储指向兄弟结点的指针；

注意：对于叶子结点来说，由于其没有孩子结点，在构建叶子结点时，将 first 指针换成 infoptr 指针，用于指向该关键字。当叶子结点（结束符 ‘$’ 所在的结点）中使用 infoptr 域指向该自身的关键字时，此时的键树被称为双链树。

如上图中的键树用孩子兄弟表示法表示为双链树时，如下图所示：

提示：每个关键字的叶子结点 $ 的 infoptr 指针指向的是各自的关键字，通过该指针就可以找到各自的关键字的首地址。

 

 

双链树查找功能的具体实现

 

在使用孩子兄弟表示法表示的键树中做查找操作，从树的根结点出发，依次同被查找的关键字进行比对，如果比对成功，进行下一字符的比对；反之，如果比对失败，则跳转至该结点的兄弟结点中去继续比对，直至比对成功或者为找到该关键字。

 

 

代码

 
KeysType 关键字类型：
 
 
Record 记录类型：
 
 
双链树类型：
 
 
 
 
  
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 


#define N 16 /* 数据元素个数 */
typedef struct
{
	int ord;
}Others; /* 记录的其它部分 */
#define Nil ' ' /* 定义结束符为空格(与教科书不同) */


/* --------------------------------     双链树的存储结构      ----------------------------------*/


#define MAXKEYLEN 16 /* 关键字的最大长度 */
typedef struct
{
	char ch[MAXKEYLEN]; /* 关键字 */
	int num; /* 关键字长度 */
}KeysType; /* 关键字类型 */

typedef struct
{
	KeysType key; /* 关键字 */
	Others others; /* 其它部分(由主程定义) */
}Record; /* 记录类型 */

typedef enum { LEAF, BRANCH }NodeKind; /* 结点种类:{叶子,分支} */
typedef struct DLTNode /* 双链树类型 */
{
	char symbol;
	struct DLTNode *next; /* 指向兄弟结点的指针 */
	NodeKind kind;
	union
	{
		Record *infoptr; /* 叶子结点的记录指针 */
		struct DLTNode *first; /* 分支结点的孩子链指针 */
	}a;
}DLTNode, *DLTree;


/* ---------------------------------------------------------------------------------------------*/


/* --------------------------------   动态查找表(双链键树)的基本操作   -------------------------------*/


Status InitDSTable(DLTree *DT)
{ /* 操作结果: 构造一个空的双链键树DT */
	*DT = NULL;
	return OK;
}

void DestroyDSTable(DLTree *DT)
{ /* 初始条件: 双链键树DT存在。操作结果: 销毁双链键树DT */
	if (*DT) /* 非空树 */
	{
		if ((*DT)->kind == BRANCH && (*DT)->a.first) /* *DT是分支结点且有孩子 */
			DestroyDSTable(&(*DT)->a.first); /* 销毁孩子子树 */
		if ((*DT)->next) /* 有兄弟 */
			DestroyDSTable(&(*DT)->next); /* 销毁兄弟子树 */
		free(*DT); /* 释放根结点 */
		*DT = NULL; /* 空指针赋0 */
	}
}

Record *SearchDLTree(DLTree T, KeysType K)
{ /* 在非空双链键树T中查找关键字等于K的记录，若存在， */
  /* 则返回指向该记录的指针，否则返回空指针。算法9.15，有改动 */
	DLTree p;
	int i;
	if (T)
	{
		p = T; /* 初始化 */
		i = 0;
		while (p&&i < K.num)
		{
			while (p&&p->symbol != K.ch[i]) /* 查找关键字的第i位 */
				p = p->next;
			if (p&&i < K.num) /* 准备查找下一位 */
				p = p->a.first;
			++i;
		} /* 查找结束 */
		if (!p) /* 查找不成功 */
			return NULL;
		else /* 查找成功 */
			return p->a.infoptr;
	}
	else
		return NULL; /* 树空 */
}

void InsertDSTable(DLTree *DT, Record *r)
{ /* 初始条件: 双链键树DT存在，r为待插入的数据元素的指针 */
  /* 操作结果: 若DT中不存在其关键字等于(*r).key.ch的数据元素， */
  /*           则按关键字顺序插r到DT中 */
	DLTree p = NULL, q = NULL, ap;
	int i = 0;
	KeysType K = r->key;
	if (!*DT&&K.num) /* 空树且关键字符串非空 */
	{
		*DT = ap = (DLTree)malloc(sizeof(DLTNode));
		for (; i < K.num; i++) /* 插入分支结点 */
		{
			if (p)
				p->a.first = ap;
			ap->next = NULL;
			ap->symbol = K.ch[i];
			ap->kind = BRANCH;
			p = ap;
			ap = (DLTree)malloc(sizeof(DLTNode));
		}
		p->a.first = ap; /* 插入叶子结点 */
		ap->next = NULL;
		ap->symbol = Nil;
		ap->kind = LEAF;
		ap->a.infoptr = r;
	}
	else /* 非空树 */
	{
		p = *DT; /* 指向根结点 */
		while (p&&i < K.num)
		{
			while (p&&p->symbol < K.ch[i]) /* 沿兄弟结点查找 */
			{
				q = p;
				p = p->next;
			}
			if (p&&p->symbol == K.ch[i]) /* 找到与K.ch[i]相符的结点 */
			{
				q = p;
				p = p->a.first; /* p指向将与K.ch[i+1]比较的结点 */
				++i;
			}
			else /* 没找到,插入关键字 */
			{
				ap = (DLTree)malloc(sizeof(DLTNode));
				if (q->a.first == p)
					q->a.first = ap; /* 在长子的位置插入 */
				else /* q->next==p */
					q->next = ap; /* 在兄弟的位置插入 */
				ap->next = p;
				ap->symbol = K.ch[i];
				ap->kind = BRANCH;
				p = ap;
				ap = (DLTree)malloc(sizeof(DLTNode));
				i++;
				for (; i < K.num; i++) /* 插入分支结点 */
				{
					p->a.first = ap;
					ap->next = NULL;
					ap->symbol = K.ch[i];
					ap->kind = BRANCH;
					p = ap;
					ap = (DLTree)malloc(sizeof(DLTNode));
				}
				p->a.first = ap; /* 插入叶子结点 */
				ap->next = NULL;
				ap->symbol = Nil;
				ap->kind = LEAF;
				ap->a.infoptr = r;
			}
		}
	}
}

typedef struct
{
	char ch;
	DLTree p;
}SElemType; /* 定义栈元素类型 */


/* --------------------------------     栈的顺序存储表示       ----------------------------------*/

#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
#define STACKINCREMENT 2 /* 存储空间分配增量 */
typedef struct SqStack
{
	SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
	SElemType *top; /* 栈顶指针 */
	int stacksize; /* 当前已分配的存储空间，以元素为单位 */
}SqStack; /* 顺序栈 */

/* ---------------------------------------------------------------------------------------------*/


/* --------------------------------   需要用到的顺序栈的基本操作  --------------------------------*/


Status InitStack(SqStack *S)
{ /* 构造一个空栈S */
	(*S).base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if (!(*S).base)
		exit(OVERFLOW); /* 存储分配失败 */
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}

Status StackEmpty(SqStack S)
{ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */
	if (S.top == S.base)
		return TRUE;
	else
		return FALSE;
}

Status Push(SqStack *S, SElemType e)
{ /* 插入元素e为新的栈顶元素 */
	if ((*S).top - (*S).base >= (*S).stacksize) /* 栈满，追加存储空间 */
	{
		(*S).base = (SElemType *)realloc((*S).base, ((*S).stacksize + STACKINCREMENT) * sizeof(SElemType));
		if (!(*S).base)
			exit(OVERFLOW); /* 存储分配失败 */
		(*S).top = (*S).base + (*S).stacksize;
		(*S).stacksize += STACKINCREMENT;
	}
	*((*S).top)++ = e;
	return OK;
}

Status Pop(SqStack *S, SElemType *e)
{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
	if ((*S).top == (*S).base)
		return ERROR;
	*e = *--(*S).top;
	return OK;
}


/* ---------------------------------------------------------------------------------------------*/



void TraverseDSTable(DLTree DT, void(*Vi)(Record))
{ /* 初始条件: 双链键树DT存在，Vi是对结点操作的应用函数， */
  /*           Vi是对记录操作的应用函数 */
  /* 操作结果: 按关键字的顺序输出关键字及其对应的记录 */
	SqStack s;
	SElemType e;
	DLTree p;
	int i = 0, n = 8;
	if (DT)
	{
		InitStack(&s);
		e.p = DT;
		e.ch = DT->symbol;
		Push(&s, e);
		p = DT->a.first;
		while (p->kind == BRANCH) /* 分支结点 */
		{
			e.p = p;
			e.ch = p->symbol;
			Push(&s, e);
			p = p->a.first;
		}
		e.p = p;
		e.ch = p->symbol;
		Push(&s, e);
		Vi(*(p->a.infoptr));
		i++;
		while (!StackEmpty(s))
		{
			Pop(&s, &e);
			p = e.p;
			if (p->next) /* 有兄弟结点 */
			{
				p = p->next;
				while (p->kind == BRANCH) /* 分支结点 */
				{
					e.p = p;
					e.ch = p->symbol;
					Push(&s, e);
					p = p->a.first;
				}
				e.p = p;
				e.ch = p->symbol;
				Push(&s, e);
				Vi(*(p->a.infoptr));
				i++;
				if (i%n == 0)
					printf("\n"); /* 输出n个元素后换行 */
			}
		}
	}
}


/* --------------------------------------------------------------------------------------------------*/



void print(Record e)
{
	int i;
	printf("(");
	for (i = 0; i < e.key.num; i++)
		printf("%c", e.key.ch[i]);
	printf(",%d)", e.others.ord);
}

void main()
{
	DLTree t;
	int i;
	char s[MAXKEYLEN + 1];
	KeysType k;
	Record *p;
	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} };
	/* 数据元素(以教科书式9-24为例) */
	InitDSTable(&t);
	for (i = 0; i < N; i++)
	{
		r[i].key.num = strlen(r[i].key.ch);
		p = SearchDLTree(t, r[i].key);
		if (!p) /* t中不存在关键字为r[i].key的项 */
			InsertDSTable(&t, &r[i]);
	}
	printf("按关键字符串的顺序遍历双链键树:\n");
	TraverseDSTable(t, print);
	printf("\n请输入待查找记录的关键字符串: ");
	scanf("%s", s);
	k.num = strlen(s);
	strcpy(k.ch, s);
	p = SearchDLTree(t, k);
	if (p)
		print(*p);
	else
		printf("没找到");
	printf("\n");
	DestroyDSTable(&t);
}

运行结果：

 
程序运行生成的树（注：叶子结点的符号为空格，箭头指向含有相应关键字符串的记录）
 
想去的远方
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Postman9.15.2
04-20
Postman9.15.2
键树的两种表示法（双链表示以及Trie树）（无主函数，可自行验证）
laohuchishizi的博客
05-09 232
键树的两种表示法
键树（双链树）C语言实现
KK的博客
12-04 810
键树 键树又称数字查找树。它是一棵度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字是数值，则结点中只包含一个数位；若关键字是单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。 举例 假设有如下16个关键字的集合{CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,LONG,WANG,ZHAO,LIU,WU,CHEN} 首先按照其首字符不同将它们分成5个子集： {CAI,CAO,CHA,C
9-10-双链树-查找-第9章-《数据结构》课本源码-严蔚敏吴伟民版
weixin_34128534的博客
06-21 118
课本源码部分 第9章  查找 - 双链树（键树） ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文件  链接☛ ...
【数据结构】算法9.15 键树-双链树-查找
Zelda 的博客
10-10 618
#include<stdio.h> #include<string.h> #include<stdlib.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2typedef int Status; typedef int ElemType;#def
DL之决策树（Decision tree）
李响
01-28 664
定义 决策树是一种常见的机器学习算法，它的思想十分朴素，类似于我们平时利用选择做决策的过程。 上，决策的形式以树的形式进行示意和编码，就形成了决策树。 结构 显然，决策树在逻辑上以树的形式存在，包含根节点、内部结点和叶节点。 根节点：包含数据集中的所有数据的集合 内部节点：每个内部节点为一个判断条件，并且包含数据集中满足从根节点到该节点所有条件的数据的集合。根据内部结点的判断条件测试结果，内部...
翼起飞YunGou CMS v9.15
12-10
1元夺宝系统是一种新型的网购模式，只需1元就有可能买到一件商品。创资源把一件商品平分成若干等份出售，每份1元，当一件商品所有等份售出后抽出一名幸运者，该幸运者即可获得此商品。 活动规则： 1
40、1271：【例9.15】潜水员+书画相关链接(六)-2020-01-13（A）.pdf
01-29
40、1271：【例9.15】潜水员+书画相关链接(六)-2020-01-13（A） 40、1271：【例9.15】潜水员+书画相关链接(六)-2020-01-13（A）
Cisco ASA 5500 Ios 9.15-k8.bin
01-13
思科 ASA 5500 系列防火墙操作系统，9.15-K8 版本！！！
内存分配器dlmalloc 2.8.3源码浅析
larryliuqing的专栏-xxx
02-01 7132
目    录 1. 本文档介绍 1 2．边界标记法 2 3. 分箱式内存管理 6 4. 核心结构体malloc_state 13 5. 内存分配相关函数 16 5.1 函数dlmalloc 16 5.2 函数tmalloc_small 25 5.3 函数tmalloc_large 27 5.4 函数sys_alloc 32 5.5 函数mmap_alloc 39 6. 内存回
看数据结构写代码（59） 键树的双链表示法
fuming0210sc的专栏
04-28 1114
杂谈; 打败自己的 往往不是敌人，而是自己。坚持不易，且行且珍惜。 键树 是一种 把  把  非叶子节点 当成索引，叶子节点保存具体信息的一种树。 例如：   它的 键树形式如下： 键树 有 两种 表示 方法：1. 双链表 表示法 ，就是 树的 孩子链表 表示法   2.多重链表表示法（Trie树） 下面给出 键树的 双链表 表示法的 插入，删除，查找  等
查找算法（V）键树——双链树和Trie树
weixin_34185320的博客
11-15 240
键树 键树的基本概念 　　键树又称数字查找树（Digital Search Tree）。 　　它是一棵度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。 　　例如，若关键字是数值，则结点中只包含一个数位；若关键字是单词，则结点中只包含一个字母字符。 　　这种树会给某种类型关键字的表的查找带来方便。 　　如下图所示为一棵键树：   　　从根到...
动态查找树 || 键树的c++实现(双链树)
perry0528的博客
03-27 472
概念： 键树又称为数字查找树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字为数值，则结点中只包含一个数位；若关键字为单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。 举例： {CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,LONG,WANG,ZHAO,LIU,WU,CHEN} 我们先针对首...
树的常见的三种链表存储结构
perry0528的博客
09-08 7804
1.双亲表示法： // - - - - - 树的双亲表存储表示 - - - - - #define MAX_TREE_SIZE 100 typedef struct PTNode { //结点结构 ElemType data; int parent; //双亲位置域 }PTNode; typedef struct { //树结构 PTNode nodes[MAX_TR...
字典树(前缀树)的实现(添加、删除、查找、查找前缀)
ZCC的专栏
01-22 4511
//字典树(前缀树)的实现(添加、删除、查找、查找前缀) public class DicTree{ public TrieNode root; //定义根节点 //字典树构造函数初始化 public DicTree() { root=new TrieNode(); } //字典树节点的定义 class TrieNode{ public int path; pub
数据结构——键树之双链表
minyuanxiani的专栏
09-03 715
#include "stdio.h" #include "stdlib.h" #include "string.h" #define OK 1 #define ERROR 0 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等 typedef int Boolean; // Boolean是布尔类型,其值是TRUE或false
树形索引（键树）
Unique-You的博客
10-18 3069
一、键树键树又称为数字查找树，它是一颗度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字为数值，则结点中只包含一个数位；若关键字为单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。        我们来举一个例子吧，下面有一个集合：{CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,...
稀疏矩阵的十字链表存储表示和实现（第五章 P104 算法5.4）
但行好事，莫问前程
03-25 7378
稀疏矩阵的十字链表存储 当矩阵的非零元个数和位置在操作过程中变化较大时，就不宜采用顺序存储结构来表示三元组的线性表。对这种类型的矩阵，采用链式存储结构表示三元组的线性表更为恰当。 在链表中，每个非零元可用一个含 5 个域的结点表示，其中 i , j , e 这 3 个域分别表示该非零元所在的行、列和非零元的值，向右域 right 用以链接同一行中下一个非零元，向下域 down 用以链接...
稀疏矩阵的三元组顺序表存储表示（第五章 P98）
但行好事，莫问前程
03-24 4795
稀疏矩阵的三元组顺序表存储表示 三元组顺序表存储结构： 三元组存储稀疏矩阵示例： typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int ElemType; #in...
安装gazebo9.15
最新发布
07-28
要安装 Gazebo9.15，您可以按照以下步骤进行操作： 1. 打开终端窗口。 2. 添加 Gazebo 的软件仓库。输入以下命令并按下 Enter 键： ``` sudo sh -c 'echo "deb ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值