键树的两种表示法（双链表示以及Trie树）（无主函数，可自行验证）

已于 2022-05-09 20:24:10 修改
阅读量236 收藏 1
点赞数
文章标签： c语言 数据结构 c++
于 2022-05-09 20:21:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124674361
版权 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <math.h>
#define OK 1
#define ERROR 0
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
#define LH 1
#define RH -1
#define EH 0
#define GRADE 4
typedef int Status;
typedef int KeyType;
typedef struct
{
	KeyType key;
}ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SSTable;
typedef ElemType TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
typedef struct BSTNode
{
	TElemType data;
	int bf;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;
typedef struct BTNode
{
	int keynum;
	struct BTNode* parent;
	KeyType key[GRADE + 1];
	struct BTNode* ptr[GRADE + 2];
	ElemType* recptr[GRADE + 1];
}BTNode, * BTree;
typedef struct
{
	BTNode* ptr;
	int i;
	int tag;
}Result;


//查找表元素输入,关键字赋值以及比较
void InputTableElem(ElemType* e)
{
	printf("请输入关键字信息\n");
	scanf("%d", &(e->key));
}
void KeyWordAssign(KeyType* destination, KeyType source)
{
	(*destination) = source;
}
void KeyWordPrint(KeyType key)
{
	printf("%d\n", key);
}
void TableElemAssign(ElemType* destination, ElemType source)
{
	(*destination).key = source.key;
}
void TableElemPrint(ElemType e)
{
	printf("%d\n", e.key);
}
Status EQ(KeyType key1, KeyType key2)
{
	if (key1 == key2)
		return TRUE;
	else
		return FALSE;
}
Status LT(KeyType key1, KeyType key2)
{
	if (key1 < key2)
		return TRUE;
	else
		return FALSE;
}
Status LE(KeyType key1, KeyType key2)
{
	if (key1 <= key2)
		return TRUE;
	else
		return FALSE;
}
Status MT(KeyType key1, KeyType key2)
{
	if (key1 > key2)
		return TRUE;
	else
		return FALSE;
}
Status ME(KeyType key1, KeyType key2)
{
	if (key1 >= key2)
		return TRUE;
	else
		return FALSE;
}


//静态查找表
Status CreatSSTable(SSTable* T, int n)
{
	T->length = n;
	T->elem = (ElemType*)malloc(sizeof(ElemType) * (n + 1));
	if (!T->elem) exit(OVERFLOW);
	for (int i = 1; i <= T->length; i++)
	{
		printf("请输入第%d个表项信息：\n", i);
		InputTableElem(&(T->elem[i]));
	}
	return OK;
}
int Search_Seq(SSTable ST, KeyType key)                   //Sequence Search
{
	KeyWordAssign(&(ST.elem[0].key), key);
	int i = ST.length;
	while (!EQ(ST.elem[i].key, key))
		i--;
	return i;
}
int Search_Bin(SSTable ST, KeyType key)                    //Binary Search
{
	int low = 1, high = ST.length;
	int mid = (low + high) / 2;
	while (low <= high)
	{
		if (EQ(ST.elem[mid].key, key))
			return mid;
		if (MT(ST.elem[mid].key, key))
			high = mid - 1;
		else
			low = mid + 1;
	}
	return 0;
}
void SecondOptimal(BiTree* T, SSTable S, int* sw, int low, int high)
{
	int i = low;
	int w = sw[high] + sw[low - 1];
	int min = abs(sw[high] - sw[low]);
	for (int j = low + 1; j <= high; j++)
	{
		if (abs(w - sw[j - 1] - sw[j]) < min)
		{
			i = j;
			min = abs(w - sw[i] - sw[i - 1]);
		}
	}
	(*T) = (BiTree)malloc(sizeof(BiTNode));
	if (!(*T)) exit(OVERFLOW);
	KeyWordAssign(&((*T)->data.key), S.elem[i].key);
	if (i == low)
		(*T)->lchild = NULL;
	else
		SecondOptimal(&((*T)->lchild), S, sw, low, i - 1);
	if (i == high)
		(*T)->rchild = NULL;
	else
		SecondOptimal(&((*T)->rchild), S, sw, i + 1, high);
}
//键树(双链树）
#define MAXKEYLEN 16
typedef struct
{
	char ch[MAXKEYLEN];
	int num;
}KeysType;
typedef struct
{
	KeysType K;
}Record;
typedef enum { LEAF, BRANCH } NodeKind;
typedef struct DLTNode
{
	char symbol;
	struct DLTNode* next;
	NodeKind kind;
	union
	{
		Record* infoptr;
		struct DLTNode* first;
	};
}DLTNode, * DLTree;
Status InputRecord(Record* R)
{
	printf("请输入关键字的字符数目\n");
	scanf("%d", &(R->K.num));
	getchar();
	printf("请逐个输入关键字字符\n");
	for (int i = 0; i < R->K.num; i++)
	{
		printf("第%d个字符为：\n", i + 1);
		R->K.ch[i] = getchar();
		getchar();
	}
	return OK;
}
Status InputKeysType(KeysType* K)
{
	printf("请输入关键字的字符数目\n");
	scanf("%d", &(K->num));
	getchar();
	printf("请逐个输入关键字字符\n");
	for (int i = 0; i < K->num; i++)
	{
		printf("第%d个字符为：\n", i + 1);
		K->ch[i] = getchar();
		getchar();
	}
	return OK;
}
Status InitDLTree(DLTree* T)
{
	(*T) = (DLTree)malloc(sizeof(DLTNode));
	if (!(*T)) exit(OVERFLOW);
	(*T)->next = NULL;
	(*T)->kind = BRANCH;
	(*T)->first = NULL;
	(*T)->symbol = '@';
	return OK;
}
Status RecordAssign(Record* R1, Record R2)
{
	R1->K.num = R2.K.num;
	for (int i = 0; i < R2.K.num; i++)
		R1->K.ch[i] = R2.K.ch[i];
	return OK;
}
Status RecordPrint(Record R)
{
	for (int i = 0; i < R.K.num; i++)
		putchar(R.K.ch[i]);
	return OK;
}
Status InsertKeysType(DLTree* T, Record R)
{
	KeysType K = R.K;
	DLTNode* p = (*T)->first, * q = *T;
	int count = 0;
	while (count < K.num)
	{
		if (p && p->symbol == K.ch[count])
		{
			q = p;
			p = p->first;
			count++;
		}
		else
		{
			if (p && p->symbol != K.ch[count])
			{
				q = p;
				p = p->next;
			}
			else
			{
				if (count - 1 >= 0 && q->symbol != K.ch[count - 1])
				{
					p = (DLTNode*)malloc(sizeof(DLTNode));
					if (!p) exit(OVERFLOW);
					p->first = NULL;
					p->kind = BRANCH;
					p->next = NULL;
					p->symbol = K.ch[count];
					q->next = p;
					q = p;
					p = p->first;
					count++;
				}
				while (count < K.num)
				{
					p = (DLTNode*)malloc(sizeof(DLTNode));
					if (!p) exit(OVERFLOW);
					p->first = NULL;
					p->kind = BRANCH;
					p->next = NULL;
					p->symbol = K.ch[count];
					q->first = p;
					q = p;
					p = p->first;
					count++;
				}
			}
		}
	}
	p = (DLTNode*)malloc(sizeof(DLTNode));
	if (!p) exit(OVERFLOW);
	p->kind = LEAF;
	p->next = NULL;
	p->symbol = '#';
	p->infoptr = (Record*)malloc(sizeof(Record));
	if (!p->infoptr) exit(OVERFLOW);
	RecordAssign(p->infoptr, R);
	q->first = p;
	return OK;
}
Record* SearchDLTree(DLTree T, KeysType K)
{
	DLTNode* p = T->first;
	int count = 0;
	while (p && count < K.num)
	{
		if (p->symbol == K.ch[count])
		{
			p = p->first;
			count++;
		}
		while (count < K.num && p && p->symbol != K.ch[count])
			p = p->next;
	}
	if (!p || p->kind != LEAF)
		return NULL;
	else
		return p->infoptr;
}


//键树（Trie树）
typedef struct TrieNode
{
	NodeKind kind;
	union
	{
		struct
		{
			KeysType K;
			Record* infoptr;
		}leaf;
		struct
		{
			struct TrieNode* ptr[27];
			int num;
		}branch;
	};
}TrieNode, * TrieTree;
Status KeysTypeAssign(KeysType* K1, KeysType K2)
{
	(*K1).num = K2.num;
	for (int i = 0; i < K2.num; i++)
		(*K1).ch[i] = K2.ch[i];
	return OK;
}
int Order(KeysType K, int m)
{
	if (m == K.num)
		return 0;
	int i = (int)K.ch[m] - 97 + 1;
	return i;
}
Status KeysTypeEqual(KeysType K1, KeysType K2)
{
	if (K1.num != K2.num)
		return FALSE;
	for (int i = 0; i < K1.num; i++)
		if (K1.ch[i] != K2.ch[i])
			return FALSE;
	return TRUE;
}
Status CreatTrieBranchNode(TrieTree* T)
{
	(*T) = (TrieTree)malloc(sizeof(TrieNode));
	if (!(*T)) exit(OVERFLOW);
	(*T)->kind = BRANCH;
	for (int i = 0; i < 27; i++)
		(*T)->branch.ptr[i] = NULL;
	(*T)->branch.num = 0;
	return OK;
}
Status InsertTrieLeafNode(TrieTree* T, Record R, int ord)
{
	(*T)->branch.num++;
	(*T)->branch.ptr[ord] = (TrieTree)malloc(sizeof(TrieNode));
	if (!(*T)->branch.ptr[ord]) exit(OVERFLOW);
	TrieNode* p = (*T)->branch.ptr[ord];
	p->kind = LEAF;
	p->leaf.infoptr = (Record*)malloc(sizeof(Record));
	if (!p->leaf.infoptr) exit(OVERFLOW);
	RecordAssign(p->leaf.infoptr, R);
	KeysTypeAssign(&(p->leaf.K), R.K);
	return OK;
}
Status InsertTrieTree(TrieTree* T, Record R, int m)
{
	if (!(*T))
	{
		CreatTrieBranchNode(T);
		int ord = Order(R.K, m);
		InsertTrieLeafNode(T, R, ord);
	}
	else
	{
		int ord = Order(R.K, m);
		TrieNode* p = (*T)->branch.ptr[ord];
		TrieNode* q;
		if (!p)
			InsertTrieLeafNode(T, R, ord);
		else
		{
			if (p->kind == LEAF)
			{
				if (KeysTypeEqual(p->leaf.K, R.K))
				{
					printf("已经存在\n");
					return ERROR;
				}
				else
				{
					CreatTrieBranchNode(&q);
					(*T)->branch.ptr[ord] = q;
					InsertTrieTree(&q, *(p->leaf.infoptr), m + 1);
					InsertTrieTree(&q, R, m + 1);
				}
			}
			else
				InsertTrieTree(&p, R, m + 1);
		}
	}
	return OK;
}
Record* SearchTrieTree(TrieTree T, KeysType K)
{
	TrieNode* p = T;
	if (!p) return NULL;
	int i = 0;
	int ord;
	while (p && i < K.num && p->kind == BRANCH)
	{
		ord = Order(K, i);
		p = p->branch.ptr[ord];
		i++;
	}
	if (!p || (p->kind == LEAF && !KeysTypeEqual(p->leaf.K, K)))
		return NULL;
	if (p->kind == LEAF)
		return p->leaf.infoptr;
	else
	{
		p = p->branch.ptr[0];
		if (p)
			return p->leaf.infoptr;
		else
			return NULL;
	}
}

哆啦BCD梦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以太坊源码分析(52）trie源码分析
尹成的技术博客
05-14 2335
包trie 实现了Merkle Patricia Tries，这里用简称MPT来称呼这种数据结构，这种数据结构实际上是一种Trie树变种，MPT是以太坊中一种非常重要的数据结构，用来存储用户账户的状态以及状态的变更，用来存储交易信息，用来存储交易的收据信息。MPT实际上是三种数据结构的组合，分别是Trie树， Patricia Trie， 和Merkle树。下面分别介绍这三种数据结构。## Tri...
论文研究-一种基于混沌游走表示法的种系发生树构建.pdf
07-22
针对生物信息学领域中种系发生树构建这一重要课题的需要, 利用DNA碱基序列的频度混沌游走表示法, 提出一种碱基序列自重复性的度量和一种序列间相关性的度量, 并由此出发, 提出了一种新的以此种相关性为依据的聚类...
双链键树的实现（第九章 P248 算法9.15）
但行好事，莫问前程
04-16 280
键树 又称为数字查找树，它是一棵度 >= 2的树，同以往所学习的树不同的是，键树的结点中存储的不是某个关键字，而是只含有组成关键字的单个符号。 如果关键字本身是字符串，则键树中的一个结点只包含有一个字符；如果关键字本身是数字，则键树中的一个结点只包含一个数位。每个关键字都是从键树的根结点到叶子结点中经过的所有结点中存储的组合。 例如，当使用键树表示查找表{CAI，CAO，CHEN，...
数据结构中的elemtype、elem是什么
热门推荐
angle1020的博客
05-02 6万+
ElemType是数据结构的书上为了说明问题而用的一个词。它是element type（“元素的类型”）的简化体。　因为数据结构是讨论抽象的数据结构和算法的，一种结构中元素的类型不一定是整型、字符型、浮点型或者用户自定义类型，为了不重复说明，使用过程中用“elemtype”代表所有可能的数据类型，简单明了的概括了整体。在算法中，除特别说明外，规定ElemType的默认是int型。elem是单词...
Trie树的实现
naturerun的博客
12-03 490
Trie树是保存字符串公共前缀信息的数据结构,可用于字符串多模匹配，普通的非压缩Trie树实现如下 第一种实现:每个分支节点使用map标准库容器保存前缀索引 #include <map> #include <stack> #include <vector> #include <string> #include <iostream> #include <random> using namespace std; enum Compa
常见的查找算法
Ricky
01-17 1635
一、顺序查找 说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表 /** * 在s[0]-s[n-1]中顺序查找关键字为Key的记录 ,查找成功时返回该记录的下标序号；失败时返回-1 */ int SequelSearch(elemtype s[], keytype Key, int n){ int i; i = 0; while (i < n &&
Trie树(字典树)的介绍及Java实现
08-31
在Java中实现Trie树，首先定义节点类`TrieNode`，包括指向26个子节点的数组（表示26个英文字母），字符数据成员`data`，以及词频计数器`freq`。例如： ```java public class TrieNode { public TrieNode[] ...
java数组-基于java实现的双数组Trie树.zip
03-14
它通过使用两个数组（一个用于表示字符位置，另一个用于表示子节点位置）来存储树的信息，从而节省空间并提高查询效率。相比传统的链式Trie，双数组Trie更紧凑，且支持高效的查找和插入操作。 在Java中实现双数组...
PHP字典树(Trie树)定义与实现方法示例
10-19
字典树，又称为Trie树或前缀树，是一种高效的数据结构，主要用于存储和检索具有公共前缀的字符串。这种数据结构能够大大减少字符串比较的次数，提高查询效率，尤其在处理大量字符串时效果显著。在搜索引擎系统中，...
javascript trie前缀树的示例
10-18
JavaScript中的Trie（前缀树）是一种数据结构，主要用于高效地存储和检索字符串。它以空间换取时间，通过利用字符串的公共前缀来减少比较次数，从而提高查询效率。Trie树由节点组成，每个节点可能包含一个字符，并且...
查找
ankeyuan的专栏
03-13 556
顺序查找 二分查找
Trie树的参考代码
caojunling的专栏
09-13 968
Trie树的参考代码 （zz）2008-05-27 18:11这个例子是用来搜索查找字的词性，假设刚开始建好了字库。类中的remove函数还没实现，具体的可以先遍历到单词在trie树的最低层结点，从下往上删除结点，碰到某个结点有2或2个以上子结点时停止。为了降低空间代价，可以用一个大数组来储存字库。而在结点中只需存储该单词在数组中的位置即可。对于非叶结点，用-1表示。在
常用数据结构
weixin_33895516的博客
05-01 117
顺序结构 顺序栈（Sequence Stack） SqStack.cpp 顺序栈数据结构和图片 typedef struct { ElemType *elem; int top; int size; int increment; } SqSrack; 队列（Sequence Queue） 队列数据结构 typedef struct { ElemT...
数据结构c语言版哈希表,c语言实现数据结构中的哈希表
weixin_34355933的博客
05-19 147
以下是我用c语言实现数据结构中的哈希表#pragmaonce;#ifndef_STDLIB_H#define_STDLIB_H#include#include#include#endif#ifndef_DEBUG_H#define_DEBUG_H#include#endif#defineHASHTABLESIZE100typedefintKeyType;#defi...
贸易常见付款方式D/P，D/A，T/T，L/C
最新发布
王小磊
07-23 560
D/P付款交单代收行必须在进口商付清货款后，才可将商业单据交给进口方D/ADocumentsagainstAcceptance承兑交单出口人的交单以进口人在汇票上承兑为条件，一般承兑时会注明具体付款的日期T/T电汇汇出行应汇款人申请，拍发加押电报给在另一国家的分行或代理行（即汇入行），指示解付一定金额给收款人L/C信用证银行根据进口人（买方）的请求，开给出口人（卖方）的一种保证承担支付货款责任的书面凭证。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 258
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
插入和选择排序
c23856的博客
07-20 495
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 352
1%29%5D1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值