嵌入式培训之数据结构学习（六）树（二叉树）、哈希表、内核链表-CSDN博客

typedef char DATATYPE; // 将char类型重命名为DATATYPE，方便后续使用，可灵活替换树节点数据类型

typedef struct _tree_node_
{
DATATYPE data; // 树节点存储的数据，类型为前面定义的DATATYPE（即char）
struct _tree_node_ *left, *right; // 指向左子节点和右子节点的指针
} TreeNode;

全局变量定义
char data[] = "abd#f###c#eg###"; // 用于构建树的字符数组，按特定格式表示树的节点，'#'表示空节点
int ind = 0; // 用于记录在data数组中当前处理的位置索引

2、树的静态创建

void CreateTree(TreeNode **root)
{
char c = data[ind++]; // 取出data数组中当前位置的字符，并将索引ind后移一位
if ('#' == c) // 如果取出的字符是'#'，表示该位置为空节点
{
*root = NULL; // 将当前节点指针设为空
return; // 结束当前递归分支
}
else
{
*root = malloc(sizeof(TreeNode)); // 为当前树节点分配内存空间
if (NULL == *root) // 如果内存分配失败
{
fprintf(stderr, "CreateTree malloc error"); // 向标准错误输出打印错误信息
return; // 结束当前递归分支
}
(*root)->data = c; // 将取出的字符赋值给当前树节点的数据域
CreateTree(&(*root)->left); // 递归创建当前节点的左子树
CreateTree(&(*root)->right); // 递归创建当前节点的右子树
}
}

3、先序遍历

void PreOrderTraverse(TreeNode *root)
{
if (NULL == root) // 如果当前节点为空，直接返回，结束当前递归分支
{
return;
}
printf("%c", root->data); // 先访问根节点，打印根节点的数据
PreOrderTraverse(root->left); // 递归遍历左子树
PreOrderTraverse(root->right); // 递归遍历右子树
}

4、中序遍历

void InOrderTraverse(TreeNode *root)
{
if (NULL == root) // 如果当前节点为空，直接返回，结束当前递归分支
{
return;
}
InOrderTraverse(root->left); // 先递归遍历左子树
printf("%c", root->data); // 再访问根节点，打印根节点的数据
InOrderTraverse(root->right); // 最后递归遍历右子树
}

5、后序遍历

void PostOrderTraverse(TreeNode *root)
{
if (NULL == root) // 如果当前节点为空，直接返回，结束当前递归分支
{
return;
}
PostOrderTraverse(root->left); // 先递归遍历左子树
PostOrderTraverse(root->right); // 再递归遍历右子树
printf("%c", root->data); // 最后访问根节点，打印根节点的数据
}

6、销毁树

void DestroyTree(TreeNode *root)
{
if(NULL == root) // 如果当前节点为空，直接返回，结束当前递归分支
{
return ;
}
DestroyTree(root->left); // 递归销毁左子树
DestroyTree(root->right); // 递归销毁右子树
free(root); // 释放当前节点的内存空间
}

7、主函数

int main(int argc, char **argv)
{
TreeNode *root = NULL; // 初始化根节点指针为空
CreateTree(&root); // 创建树，传入根节点指针的地址
PreOrderTraverse(root); // 对树进行先序遍历并打印节点
puts(""); // 打印换行符
InOrderTraverse(root); // 对树进行中序遍历并打印节点
puts(""); // 打印换行符
PostOrderTraverse(root); // 对树进行后序遍历并打印节点
puts(""); // 打印换行符
DestroyTree(root); // 销毁树，释放树占用的内存
root = NULL; // 将根节点指针设为空
// system("pause"); // 被注释掉，原本可能用于暂停程序，在Windows下常见，Linux下一般无此需求
return 0; // 程序正常结束返回0
}

二、哈希表（散列表）

（一）哈希表的基本概念

1、定义：

散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得

每个关键字 key 对应一个存储位置f(key)。查找时，根据这个确定的对应关系找到给定

值 key的映射f(key)，若查找集合中存在这个记录，则必定在f(key)的位置上这里我们把

这种对应关系f称为散列函数，又称为哈希(Hash)函数。按这个思想，采用散列技术将记

录存储在一块连续的存储空间中，这块连续存储空间称为散列表或哈希(Hashtabke)。

那么关键字对应的记录存储位置我们称为散列地址。

2、散列表的查找步骤：（目的：快速查找）

（1）在存储时，通过散列函数计算记录的散列地址，并按此散列地址存储该记；

（2）当查找记录时，我们通过同样的散列函数计算记录的散列地址，按此散列地址访

问该记录。

注：散列技术既是一种存储方法，也是一种查找方法。

3、现实中，应该视不同的情况采用不同的散列函数，一些考虑的因素来提供参考:

（1）计算散列地址所需的时间。

（2）关键字的长度。

（3）散列表的大小。

（4）关键字的分布情况。

（5）记录查找的频率。综合这些因素，才能决策选择哪种散列函数更合适。

4、设计散列函数注意事项：

（1）计算速度快（相对简单）；

（2）下标在一定范围内要相对均匀分布。

5、常用的构造散列函数方法：（除留余数法）

对于散列表长为m的散列函数公式为: f( key )=key mod p(p≤m )

mod 是取模(求余数)的意思。事实上，这方法不仅可以对关键字直接取，也在折叠、平

方取中后再取模。

6、处理散列冲突的方法：由于哈希函数可能将不同的键映射到相同的哈希值，因此会

发生哈希冲突，常见的冲突解决方法包括链地址法和开放地址法。

链地址法：每个数组位置存储一个链表，所有哈希值相同的键值对都存储在这个链表中；

开放地址法：当发生冲突时，通过探测方法（如线性探测、二次探测）寻找下一个

可用的位置。

（二）哈希表的基本操作

1、数据类型的定义

typedef int DATATYPE; // 将int类型重命名为DATATYPE，方便后续表示哈希表存储的数据类型

typedef struct
{
DATATYPE* head; // 指向哈希表存储数据的数组指针
int tlen; // 哈希表的长度
} HSTable;

2、创建哈希表

HSTable* CreateHsTable(int len)
{
HSTable* hs = malloc(sizeof(HSTable)); // 为哈希表结构体分配内存
if (NULL == hs) // 如果内存分配失败
{
fprintf(stderr, "CreateHsTable malloc error"); // 向标准错误输出打印错误信息
return NULL; // 返回空指针表示创建失败
}
hs->head = malloc(sizeof(DATATYPE) * len); // 为哈希表的数据存储数组分配内存
if (NULL == hs->head) // 如果内存分配失败
{
fprintf(stderr, "CreateHsTable malloc2 error"); // 向标准错误输出打印错误信息
return NULL; // 返回空指针表示创建失败
}
hs->tlen = len; // 设置哈希表的长度
int i = 0;
for (i = 0; i < len; i++) // 初始化哈希表数组，将每个元素设为-1
{
hs->head[i] = -1; // -1表示该位置为空
}
return hs; // 返回创建好的哈希表指针
}

3、哈希函数

int HSFun(HSTable* hs, DATATYPE* data)

{

return *data % hs->tlen;

} // 哈希函数，通过取余计算数据在哈希表中的索引位置

4、数据放入哈希表内

int HSInsert(HSTable* hs, DATATYPE* data)
{
int ind = HSFun(hs, data); // 通过哈希函数计算数据应插入的索引位置
while (hs->head[ind] != -1) // 如果该位置已被占用（不为-1）
{
printf("pos %d, num:%d\n", ind, *data); // 打印冲突位置和要插入的数据
ind = (ind + 1) % hs->tlen; // 采用线性探测法寻找下一个空位置
}
hs->head[ind] = *data; // 将数据插入到找到的空位置
return 0; // 插入成功返回0
}

5、查找函数

int HsSearch(HSTable* hs, DATATYPE* data)
{
int ind = HSFun(hs, data); // 通过哈希函数计算数据在哈希表中的起始索引位置
int old_ind = ind; // 保存起始索引位置
while (hs->head[ind] != *data) // 当当前位置的数据与要查找的数据不相等时
{
ind = (ind + 1) % hs->tlen; // 采用线性探测法寻找下一个位置
if (old_ind == ind) // 如果回到了起始位置，说明没找到
{
return -1; // 返回-1表示未找到
}
}
return ind; // 返回找到数据的索引位置
}

6、主函数调用

int main(int argc, char** argv)
{
HSTable* hs = CreateHsTable(12); // 创建长度为12的哈希表
int array[] = {12, 67, 56, 16, 25, 37, 22, 29, 15, 47, 48, 34}; // 定义要插入哈希表的数据数组
int i = 0;
for (i = 0; i < 12; i++) // 遍历数组，将数据插入哈希表
{
HSInsert(hs, &array[i]); // 插入数据到哈希表
}
int want_num = 37; // 定义要查找的数据
int ret = HsSearch(hs, &want_num); // 在哈希表中查找数据
if (-1 == ret) // 如果返回-1，说明未找到
{
printf("not find \n"); // 打印未找到信息
}
else // 找到数据
{
printf("find ,%d\n", hs->head[ret]); // 打印找到的数据
}
// system("pause"); // 被注释掉，原本可能用于暂停程序（在Windows下常见，Linux下一般无此需求）
return 0; // 程序正常结束返回0
}