看数据结构写代码（59） 键树的双链表示法

最新推荐文章于 2020-12-04 16:43:08 发布
原创 最新推荐文章于 2020-12-04 16:43:08 发布 · 1.1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#键树 #键树的双链表表示法 #键树的双链表表示法C语言描述

键树，又称Trie树，是哈希树的变种，常用于字符串统计和排序。本文介绍了键树的概念，特点，以及如何用双链表表示法进行插入、删除和查找操作。此外，还探讨了键树在串的快速检索、串排序和最长公共前缀等应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

杂谈; 打败自己的 往往不是敌人，而是自己。坚持不易，且行且珍惜。


键树又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高

键树的根节点不包含字符，除根节点外的非叶子节点都只包含一个字符，叶子节点存储具体信息。； 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； 每个节点的所有子节点包含的字符都不相同。并且 兄弟节点 按 按 字符大小 排序。


例如：

 

它的 键树形式如下：



键树的应用：（摘自百度）

串的快速检索

给出N个单词组成的熟词表，以及一篇全用小写英文书写的文章，请你按最早出现的顺序写出所有不在熟词表中的生词。
在这道题中，我们可以用 数组枚举，用哈希，用字典树，先把熟词建一棵树，然后读入文章进行比较，这种方法效率是比较高的。

串”排序

给定N个互不相同的仅由一个单词构成的英文名，让你将他们按 字典序从小到大输出
用字典树进行排序，采用 数组的方式创建字典树，这棵树的每个结点的所有儿子很显然地按照其字母大小排序。对这棵树进行先序遍历即可。

最长公共前缀

对所有串建立字典树，对于两个串的最长公共前缀的长度即他们所在的结点的公共祖先个数，于是，问题就转化为当时公共祖先问题。




键树 有 两种 表示 方法：1. 双链表 表示法 ，就是 树的 孩子链表 表示法   2.多重链表表示法（Trie树）


下面给出 键树的 双链表 表示法的 插入，删除，查找  等功能 代码：


完整源代码网盘地址：http://yun.baidu.com/share/link?shareid=582619924&uk=1208029266



// DSTree.cpp : 定义控制台应用程序的入口点。
//键树的双链树表示法

#include "stdafx.h"
#include <cstdlib>
#include <cstring>
#include "queue.h"
#include "stack.h"

#define MAX_KEY_LEN	16
#define LEAF_END_CHAR '$'//叶子节点结束符
struct KeyType{
	char key[MAX_KEY_LEN];
	int len;
};

void initKey(KeyType * kt,char * k){
	int len = strlen(k);
	strncpy(kt->key,k,len+1);
	kt->len = len;
}

enum E_Kind{
	E_Kind_Leaf,
	E_Kind_Branch,
};
typedef struct DLNode{
	char data;
	DLNode * nextSibling;//下一个兄弟节点
	E_Kind kind;;
	union
	{
		char * record;//叶子节点的信息
		DLNode * firstChild;//第一个孩子节点(分支节点）
	};
}*DLTree;

DLNode * makeNode(E_Kind kind){
	DLNode * node = (DLNode *)malloc(sizeof(DLNode));
	node->kind = kind;
	node->nextSibling = NULL;
	if (node->kind == E_Kind_Branch){
		node->firstChild = NULL;
	}
	else{
		node->record = (char *)malloc(sizeof(char)*MAX_KEY_LEN);
		node->data = LEAF_END_CHAR;
	}
	return node;
}

void initTree(DLTree * tree){
	*tree = NULL;
}

void destoryTree(DLTree * tree){
	DLTree p = *tree;
	if (p != NULL){
		if (p->kind == E_Kind_Leaf){
			free(p->record);
		}
		else{
			destoryTree(&p->firstChild);
		}
		destoryTree(&p->nextSibling);
		free(p);
		*tree = NULL;
	}
}

DLTree  search(DLTree t,char * k){
	if (t != NULL)
	{
		KeyType kt;
		initKey(&kt,k);
		int times = 0;
		t = t->firstChild;
		while (t && times < kt.len){
			while (t && t->data < kt.key[times]) t = t->nextSibling;
			if (t && t->data == kt.key[times]){
				t = t->firstChild;
				times++;
			}
			else{
				return NULL;
			}
		}
		if (times == kt.len && t->kind == E_Kind_Leaf){
			return t;
		}
	}
	return NULL;
}

//搜索结果.为插入 关键字 服务
//是第一个孩子节点：tree:返回 父亲节点 ，不是 返回 兄弟节点.
struct Result{
	bool isFind;//是不是找到了
	bool isFirst;//是不是第一个孩子节点
	DLTree tree;//插入位置
	int index;//需要插入的节点 的位置.
};

Result searchForInsert(DLTree tree,KeyType key){
	int times = 0;
	Result result;
	result.isFirst = false;
	result.isFind = false;
	while (tree && times < key.len){
		DLTree fatherNode = tree;
		result.index = times;
		tree = tree->firstChild;
		while (tree){
			if (tree->data > key.key[times]){
				if (fatherNode->firstChild == tree){
					result.isFirst = true;
					result.tree = fatherNode;
				}
				return result;
			}
			else if(tree->data == key.key[times]){
				result.tree = tree;
				times ++;
				break;
			}
			else{// $ 比 a ~ z 小
				result.tree = tree;
				tree = tree->nextSibling;
			}
		}
	}
	if ( times == key.len){//全部都相等
		if (tree && tree->firstChild && tree->firstChild->kind == E_Kind_Leaf){
			result.isFind = true;
			result.tree = tree->firstChild;
		}
		else{
			result.isFirst = true;
			result.index = times;
		}
	}
	return result;
	
}

void insert(DLTree t,KeyType kt,int index){
	for (int i = index; i < kt.len; i++){
		DLNode * node = makeNode(E_Kind_Branch);
		node->data = kt.key[i];
		t->firstChild = node;
		t = node;
	}
	//最后插入叶子节点
	DLNode * leaf = makeNode(E_Kind_Leaf);
	strncpy(leaf->record,kt.key,kt.len+1);
	t->firstChild = leaf;
}

void insertTree(DLTree * tree,char * key){
	KeyType kt;
	initKey(&kt,key);
	if (*tree == NULL){//空树，需要设置一个根节点
	    *tree = makeNode(E_Kind_Branch);
		insert(*tree,kt,0);
		return;
	}
	Result result = searchForInsert(*tree,kt);
	if (result.isFind == false){//没找到，再插入.
		if (result.isFirst){//插入在头部
			DLTree fatherNode = result.tree;
			DLTree oldFirst = fatherNode->firstChild;
			insert(fatherNode,kt,result.index);
			fatherNode->firstChild->nextSibling = oldFirst;
		}
		else{
			DLTree leftBrother = result.tree;
			DLNode * node = makeNode(E_Kind_Branch);
			node->data = kt.key[result.index];
			node->nextSibling = leftBrother->nextSibling;
			leftBrother->nextSibling = node;
			insert(node,kt,result.index+1);
		}
	}
}

void deleteTree(DLTree * t,char * k){
	if (*t != NULL)
	{
		KeyType kt;
		initKey(&kt,k);
		DLTree p = (*t)->firstChild;
		int times = 0;
		linkStack stack;
		stackInit(&stack);
		stackPush(&stack,*t);
		while (p && times < kt.len){
			while (p && p->data < kt.key[times]) p = p->nextSibling;
			if (p && p->data == kt.key[times]){
				stackPush(&stack,p);
				p = p->firstChild;
				times++;
			}
			else{
				return;//没找到
			}
		}
		if (p && p->kind == E_Kind_Leaf){
			DLTree f = NULL;
			while (!stackEmpty(stack)){
				stackPop(&stack,&f);
				if (f->firstChild == p && p->nextSibling == NULL){//父亲只有 一个孩子
					free(p);
					p = f;
					if (*t == f){//所有关键字都被删除了，空树..
						free(*t);
						*t = NULL;
						return;
					}
				}
				else{
					break;
				}
			}
			if (f->firstChild == p){
				f->firstChild = p->nextSibling;
			}
			else{
				DLTree pre = f->firstChild;
				while (pre != NULL && pre->nextSibling != p) pre = pre->nextSibling;
				pre->nextSibling = p->nextSibling;
			}
			free(p);
		}
		stackDestory(&stack);
	}
}

//层序遍历
void levelTraverse(DLTree tree){
	if (tree != NULL){
		if (tree->firstChild != NULL){
			printf("----------------层序遍历----------------\n");
			LinkQueue queue;
			queueInit(&queue);
			enqueue(&queue,tree->firstChild);
			int count = 1;
			int level = 1;
			int nextCount = 0;
			while (!queueEmpty(queue)){
				printf("%d 层数据：",level);
				for (int i = 0; i < count; i++){
					DLTree t;
					dequeue(&queue,&t);
					while (t){
						printf("%c   ",t->data);
						if (t->kind == E_Kind_Branch &&  t->firstChild != NULL){
							enqueue(&queue,t->firstChild);
							nextCount++;
						}
						t = t->nextSibling;
					}
				}
				printf("\n");
				count = nextCount;
				nextCount = 0;
				level++;
			}
			queueDestory(&queue);
			printf("\n");
		}
	}
}


static char testArray[][MAX_KEY_LEN] = {//18 个
	"cao","cai","chang","chao","cha","chen",//6
	"wen","wang","wu",//3
	"zhao",//1
	"li","lan","long","liu",//4
	"yun","yang",//2
	"zha","l",
};

int _tmain(int argc, _TCHAR* argv[])
{
	DLTree root;
	initTree(&root);
	for (int i = 0; i < 16; i++){
		insertTree(&root,testArray[i]);
	}
	levelTraverse(root);
	for (int i = 0; i < 18; i++){
		char  * s = testArray[i];
		DLTree t = search(root,s);
		if (t){
			printf("查找 %s后，记录为：%s\n",s,t->record);
		}
		else{
			printf("查找 %s,没找到\n",s);
		}
	}
	for (int i = 0; i < 18; i++){
		char * s = testArray[i];
		deleteTree(&root,s);
		printf("-------------删除%s后--------------\n",s);
		levelTraverse(root);
	}
	destoryTree(&root);
	return 0;
}




数据结构---键树（C语言）
06-04
数据结构 C语言 键树 如果一个关键字可以表示成字符的序号，即字符串，那么可以用键树（keyword tree），又称数字搜索树（digital search tree）或字符树，来表示这样的字符串的集合。
查找算法（V）键树——双链树和Trie树
weixin_34185320的博客
11-15 286
键树 键树的基本概念 　　键树又称数字查找树（Digital Search Tree）。 　　它是一棵度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。 　　例如，若关键字是数值，则结点中只包含一个数位；若关键字是单词，则结点中只包含一个字母字符。 　　这种树会给某种类型关键字的表的查找带来方便。 　　如下图所示为一棵键树：   　　从根到...
动态查找树 || 键树的c++实现(双链树)
perry0528的博客
03-27 556
概念： 键树又称为数字查找树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字为数值，则结点中只包含一个数位；若关键字为单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。 举例： {CAI,CAO,LI,LAN,CHA,CHANG,WEN,CHAO,YUN,YANG,LONG,WANG,ZHAO,LIU,WU,CHEN} 我们先针对首...
数据结构——键树
weixin_33719619的博客
08-26 165
       偶然在网上看见C#实现的键树，以前不知这东东是啥玩意（数据结构没过关），有何用途？于是仔细研学了一把，本人对这种算法的东西，看着就头痛，自己照着做了一遍。基本参考网上已实现的代码算法，放于此，给自己做个参考，以备查阅。以下是代码：  using System; using System.Collections.Generic; using System.Text; n...
键树
zhangchuan的博客
08-24 1955
键树又称数字查找树，它是一棵度大于等于2的树，树中的节点不是包含一个或几个关键字，而只是包含组成关键字的符号。如果关键字是数值，则节点中的元素为一位的数字；如果关键字为字符，则节点中的元素为26个字符。如下是一棵键树。 从根节点到叶子结点路径上的元素组成一个关键字，其中叶子结点的特殊字符表示字符串的结束。 叶子节点中有指向关键字记录的指针。 为了查找的方便，我们约定同一层兄弟
双链键树的实现（第九章 P248 算法9.15）
但行好事，莫问前程
04-16 331
键树 又称为数字查找树，它是一棵度 >= 2的树，同以往所学习的树不同的是，键树的结点中存储的不是某个关键字，而是只含有组成关键字的单个符号。 如果关键字本身是字符串，则键树中的一个结点只包含有一个字符；如果关键字本身是数字，则键树中的一个结点只包含一个数位。每个关键字都是从键树的根结点到叶子结点中经过的所有结点中存储的组合。 例如，当使用键树表示查找表{CAI，CAO，CHEN，...
数据结构——键树之双链表
minyuanxiani的专栏
09-03 782
#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
【数据结构】算法9.15 键树-双链树-查找
Zelda 的博客
10-10 697
#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
数据结构——键树之Tire树
minyuanxiani的专栏
09-03 772
#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
键树（双链树）C语言实现
KK的博客
12-04 1028
键树 键树又称数字查找树。它是一棵度大于等于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 155
课本源码部分 第9章  查找 - 双链树（键树） ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本源码引入的文件  链接☛ ...
键树及其存储结构(应用于IK Analyzer)
高毅的博客
09-25 900
键树，又称数字查找树。它是一棵度>=2的树，树中的每个节点不是包含一个或者几个关键字，而是只是组成关键字的符号。如，若关键字是单词，则节点中只包含一个字母字符。     键树有两种存储结构：一是双链树，而是Trie树。     由于在分词器中采用了Tried树作为存储结构，故写本文以熟悉该结构。     关于Trie树     在该树中分为叶子节点和分支节点，叶子节点中含有关键字域和指向相
键树算法的实现
编程浪子的专栏
11-10 1498
键树算法在计费系统中非常普遍，用来在共享内存中查找用户资料的时候，非常快，查找代价始终是常数级别。下面是源码广泛应用在国内的计费系统之中，其中alloctor，dealloctor函数是用来在共享内存中分配和释放内存的，可以参考我的另一篇文章为C++标准库容器写自己的内存分配程序另外重复键值的算法采用的是线性链表的算法，比较简单，所以就没有列出源码。h_trie.h#ifnde
键树和字典树
linux系统、网络编程和分布式计算
03-11 1290
一键树(数字查找树)： (1)特点： *键树是一棵度>=2的树，树中的每个结点中只含有组成组成关键字的符号，而不是包含一个或几个关键字，叶子结点包括指向记录的指针。 (2)存储结构： *孩子兄弟链表 *多重链表。 二 Trie树(字典树)：键树用多重链表的表示便是Trie树。 三 总结： *查找都是从根节点开始，走了一条从根到叶子(或非终端结点)的路径，其查找时间依
【数据结构】高效双向链表list、树tree（二叉树）
Hello, New World!
01-14 918
vi正常模式下： "shift + g" 跳到最后一行 "gg" 跳到第一行 /*代码*/ 01link.c #include #include "01link.h" //链表初始化 void link_init(Link *p_link) {      p_link->head.p_next = &(p_link->tail);     p_link->tail.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值