C/C++ 比 ‘二叉树算法’ 效率更高的 ‘哈希表算法’

最新推荐文章于 2023-03-21 23:09:18 发布
最新推荐文章于 2023-03-21 23:09:18 发布
阅读量902 收藏 3
点赞数 3
分类专栏： 算法 文章标签： 算法 指针 链表 数据结构 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp_learner/article/details/106613397
版权

哈希表的简介

今天写下一篇哈希表算法，他的查找效率可是比二叉树还要高。

哈希表的运用场景还是挺多的，比如‘分布式文件系统存储引擎’、‘基因测试’等。

哈希表 又称 散列表，它是基于快速存取的角度设计的，也是一种典型的“空间换时间”的做法。

他主要是由五部分组成：

––
键(key)组员的编号 如， 1 、 5 、 19 。 。 。
值(value)组员的其它信息（包含 性别、年龄和战斗力等）
索引数组的下标(0,1,2,3,4) ，用以快速定位和检索数据
哈希桶保存索引的数组(链表或数组)，数组成员为每一个索引值相同的多个元素
哈希函数将组员编号映射到索引上，采用求余法 ，如： 组员编号 19

哈希函数最常用的就是取余法了，当然也可以使用其他的方法，根据具体项目情况定夺。

解析：

  1. 键：他是唯一的，通过键可以快速找到其对应的值。
  2. 值：所存储的元素。
  3. 索引：可以通过索引找到在某个哈希桶里面，进而缩短了查询时间。
  4. 哈希桶：每个索引对应一个哈希桶，每个哈希桶里面存储n个值。
  5. 哈希函数：通过键除以哈希桶的数量取余，而得到索引。

如下图：
在这里插入图片描述

  1. 图中二十个数据，也就有对应的二十个键。
  2. 我们可以将其分成1 - 20 个哈希桶存储，这里就以5个桶为例。
  3. 0 - 19 是它的键，使用键除以哈希桶的数量取余，就可以得到键对应存储在哪个哈希桶里。
  4. 经过一轮的操作，就可以将全部数据存储进哈希桶里，形成一张完美的哈希表了。

在这里说明一下：为什么哈希桶的效率要比二叉树高？

以上表为例，假如我们需要查找键为3的数据，那么我们将13除以哈希桶的数量再取余，就可以得到对应哈希桶的索引，也就是下图这个桶（每一行代表一个哈希桶）。
在这里插入图片描述
可以看到我们一次就排除了4/5的数据，比二叉树一次只能排除一半的数据效率要高很多。
然后再从这个桶里面一个一个的比较就可以找到键为13的元素了。
当然，如果20个数据，我们使用二十个哈希桶来存储的话，只是需要一次比较就可以找到该值了，这就是上面所说的一种典型的“空间换时间”的做法。

算法实现

哈希表的定义

需要两个结构体：

  1. 哈希表所存储元素的结构体
  2. 哈希表的结构体

也需要一个默认的哈希桶的最大个数

#define DEFAULT_SIZE 16		// 默认最大哈希桶个数

// 哈希表的元素
typedef struct _LinkNode {
	struct _LinkNode *next;		// 下一个节点
	int key;					// 键值（唯一）
	void *data;					// 元素
}LinkNode;

// 两个类型一样，为了方便阅读代码，才分开两个
typedef LinkNode *Link;		// 链表
typedef LinkNode *Element;	// 节点


// 哈希表
typedef struct _HashTable {
	int tableSize;		// 哈希桶的个数（索引个数）
	Link *theLists;		// 存储所有哈希桶头节点的指针数组
}HashTable;

哈希表的初始化

哈希表使用最多的是使用链表的方式来存储数据。

所以初始化哈希表时，需要三个分配内存的步骤：

  1. 为整个哈希表分配内存；
    在这里插入图片描述
  2. 为存储哈希桶头部分配内存，通常为指针数组，且不存储元素（下表为了方便描述才…)；
    在这里插入图片描述
  3. 为每个哈希桶的头节点分配内存。
    在这里插入图片描述

代码中都有详细注释：

// 初始化哈希表
HashTable *InitHashTable(int tableSize) {	// 参数一：哈希桶的数量（索引数量）
	HashTable *hTable = NULL;	// 定义哈希表对象返回

	// 检测哈希桶数量的合理性检查
	if (tableSize <= 0) {
		tableSize = DEFAULT_SIZE;	// 不合法将宏定义的默认值赋值给tableSize
	}

	// 哈希表分配内存
	hTable = (HashTable *)malloc(sizeof(HashTable));	// 相当于 hTable = new HashTable;
	if (!hTable) {
		cout << "HashTable 分配内容失败！" << endl;
		return NULL;
	}


	hTable->tableSize = tableSize;	// 赋值哈希桶数量

	//为 Hash 桶分配内存空间，其为一个指针数组
	hTable->theLists = (Link *)malloc(sizeof(Link) * tableSize);	// 相当于 hTable->theLists = new Link[tableSize];
	if (!hTable->theLists) {
		cout << "hTable->theLists 分配内存失败！" << endl;
		free(hTable);	// 释放哈希表的内存
		return NULL;
	}


	//为 Hash 桶对应的指针数组初始化链表节点
	for (int i = 0; i < tableSize; i++) {
		hTable->theLists[i] = (LinkNode *)malloc(sizeof(LinkNode));	// 相当于 hTable->theLists[i] = new LinkNode;
		if (!hTable->theLists[i]) {
			cout << "hTable->theLists[i] 分配内存失败！" << endl;
			free(hTable->theLists);	// 释放之前分配的所有内存
			free(hTable);			// 释放哈希表的内存
			return NULL;
		} else {
			// 将节点元素中的所有值都赋值0
			memset(hTable->theLists[i], 0, sizeof(LinkNode));
		}
	}


	return hTable;
}

哈希表的查找

这时就需要使用到哈希函数了：

// 哈希函数，计算该键值对应的索引返回
int Hash(int key, int tableSize) {	// 参数一：键值；参数二：哈希桶的数量（索引数量）
	return (key % tableSize);	// 这里采用取余法
}

根据索引定位到具体的哈希桶，再通过链表的方式一个一个的遍历比较键，直到找到相同的键，将其对应的元素返回；当没有找到，就返回NULL。

// 从哈希表中根据键值查找元素
Element Find(HashTable *hTable, int key) {	// 参数一：哈希表；参数二：键值
	int i = 0;			// 保存键值对应的哈希桶的下标索引
	Link L = NULL;		// 保存对应哈希桶的头节点
	Element e = NULL;	// 用于循环遍历

	if (!hTable) {
		return NULL;
	}


	i = Hash(key, hTable->tableSize);	// 找到索引
	L = hTable->theLists[i];			// 将对应的哈希桶头节点赋值给L
	e = L->next;						// 从L的下一个节点开始查找

	// 结束条件：没有找到，返回NULL； 找到了，返回键值对应的节点
	while (e != NULL && e->key != key) {
		e = e->next;
	}

	return e;
}

哈希表的插入

  1. 先通过哈希表的查找函数进行键的配对，如果已经有相同的键了，根据具体项情况进行定夺，这里我就以输出一句话作为提示。
  2. 当哈希表中没有相同的键时，分配一个元素节点的内存，然后再根据键找到哈希桶的索引，再找到哈希桶，最后根据头插法进行插入（也可以使用尾插法等）。
// 哈希表插入元素，元素为键值对
void Insert(HashTable *hTable, int key, void *value) {	// 参数一：哈希表；参数二：键值；参数三：待插入的值
	int i = 0;				// 保存键值对应的哈希桶索引
	Link L = NULL;			// 保存键值对应的哈希桶的头节点
	Element e = NULL;		// 查找判断哈希表中是否已经存在相同的键值
	Element tem = NULL;		// new新对象插入
	

	if (!hTable || !value) {
		return;
	}

	// 查找判断哈希表中是否已经存在相同的键值
	e = Find(hTable, key);

	// 等于NULL说明没有哈希表中没有相同的键值，可以插入
	if (e == NULL) {

		// 为新插入的哈希元素分配内存
		tem = (Element)malloc(sizeof(LinkNode));		// 相当于 tem = new LinkNode;	
		if (!tem) {
			cout << "查找函数中的Element类型分配内存失败！" << endl;
			return;
		}

		// 保存值待插入
		tem->data = value;
		tem->key = key;

		i = Hash(key, hTable->tableSize);	// 获取索引
		L = hTable->theLists[i];			// 根据索引获取对应的哈希桶头节点

		// 使用头插法插入
		tem->next = L->next;
		L->next = tem;
	} else {
		cout << "插入失败，哈希表有重复的键值！" << endl;
	}
}

哈希表的元素删除

  1. 由索引找到哈希桶，再有哈希桶的头节点开始遍历，一个变量保存对应键的元素，一个变量保存对应键的前一个元素。
  2. 进行第一个变量的判断，当他不等于NULL，说明哈希表中有该键值对应的元素。
  3. 将第二个变量的next指向待删除节点的next，就完成分离。最后free释放掉内存即可。
// 哈希表删除元素，元素为键值对
void Delete(HashTable *hTable, int key) {	// 参数一：哈希表；参数二：键值
	int i = 0;					// 保存键值对应的哈希桶索引
	Link L = NULL;				// 保存键值对应的哈希桶的头节点
	Element e = NULL;			// 保存待删除节点
	Element last = NULL;		// 保存待删除节点的前一个节点
	
	if (!hTable) {
		return;
	}

	i = Hash(key, hTable->tableSize);
	L = hTable->theLists[i];
	e = L->next;
	last = L;	

	while (e != NULL && e->key != key) {
		last = e;		// last永远指向待删除节点的前一个节点
		e = e->next;
	}

	//如果键值对存在
	if (e != NULL) {
		last->next = e->next;
		delete e;
	}
}

哈希表的销毁

  1. 由for循环从索引0开始，将对应哈希桶里面的节点元素释放完后，再将哈希桶释放，然后索引值加一，直到释放完所有的哈希桶内存为止。
  2. 最后释放存储哈希桶头节点的指针数组内存和哈希表的内存。
// 销毁哈希表
void Destroy(HashTable *hTable) {
	Link L = NULL;			// 保存哈希桶头节点
	Element cur = NULL;		// 用于遍历与释放
	Element next = NULL;	// 用于辅助遍历与释放

	if (!hTable) {
		return;
	}

	// 从零开始遍历哈希桶，直到遍历完为止
	for (int i = 0; i < hTable->tableSize; i++) {
		L = hTable->theLists[i];	// 获取第i个哈希桶
		cur = L->next;				// 从哈希桶的下一个节点开始遍历

		while (cur != NULL) {
			next = cur->next;		// next指向当前节点的下一个节点
			free(cur);				// 释放当前节点
			cur = next;				// cur获取自己的下一个节点
		}

		free(L);					// 释放当前第i的哈希桶内存
	}

	free(hTable->theLists);			// 释放存储哈希桶头节点的内存
	free(hTable);					// 释放哈希表

	cout << "释放成功" << endl;
}

全部代码：

HashTable.h

#pragma once

#define DEFAULT_SIZE 16		// 默认最大哈希桶个数

// 哈希表的元素
typedef struct _LinkNode {
	struct _LinkNode *next;		// 下一个节点
	int key;					// 键值（唯一）
	void *data;					// 元素
}LinkNode;

// 两个类型一样，为了方便阅读代码，才分开两个
typedef LinkNode *Link;		// 链表
typedef LinkNode *Element;	// 节点


// 哈希表
typedef struct _HashTable {
	int tableSize;		// 哈希桶的个数（索引个数）
	Link *theLists;		// 存储所有哈希桶头节点的指针数组
}HashTable;



// 哈希函数，计算该键值对应的索引返回
int Hash(int key, int tableSize);	// 参数一：键值；参数二：哈希桶的数量（索引数量）


// 初始化哈希表
HashTable* InitHashTable(int tableSize);	// 参数一：哈希桶的数量（索引数量）


// 从哈希表中根据键值查找元素
Element Find(HashTable *hTable, int key);	// 参数一：哈希表；参数二：键值


// 哈希表插入元素，元素为键值对
void Insert(HashTable *hTable, int key, void *value);	// 参数一：哈希表；参数二：键值；参数三：待插入的值


// 哈希表删除元素，元素为键值对
void Delete(HashTable *hTable, int key);	// 参数一：哈希表；参数二：键值


// 销毁哈希表
void Destroy(HashTable* hTable);	// 参数一：哈希表


/*哈希表元素中提取数据*/
void *Retrieve(Element e);

HashTable.cpp

#include <iostream>
#include <Windows.h>
#include "HashTable.h"

using namespace std;

// 哈希函数，计算该键值对应的索引返回
int Hash(int key, int tableSize) {	// 参数一：键值；参数二：哈希桶的数量（索引数量）
	return (key % tableSize);	// 这里采用取余法
}



// 初始化哈希表
HashTable *InitHashTable(int tableSize) {	// 参数一：哈希桶的数量（索引数量）
	HashTable *hTable = NULL;	// 定义哈希表对象返回

	// 检测哈希桶数量的合理性检查
	if (tableSize <= 0) {
		tableSize = DEFAULT_SIZE;	// 不合法将宏定义的默认值赋值给tableSize
	}

	// 哈希表分配内存
	hTable = (HashTable *)malloc(sizeof(HashTable));	// 相当于 hTable = new HashTable;
	if (!hTable) {
		cout << "HashTable 分配内容失败！" << endl;
		return NULL;
	}


	hTable->tableSize = tableSize;	// 赋值哈希桶数量

	//为 Hash 桶分配内存空间，其为一个指针数组
	hTable->theLists = (Link *)malloc(sizeof(Link) * tableSize);	// 相当于 hTable->theLists = new Link[tableSize];
	if (!hTable->theLists) {
		cout << "hTable->theLists 分配内存失败！" << endl;
		free(hTable);	// 释放哈希表的内存
		return NULL;
	}


	//为 Hash 桶对应的指针数组初始化链表节点
	for (int i = 0; i < tableSize; i++) {
		hTable->theLists[i] = (LinkNode *)malloc(sizeof(LinkNode));	// 相当于 hTable->theLists[i] = new LinkNode;
		if (!hTable->theLists[i]) {
			cout << "hTable->theLists[i] 分配内存失败！" << endl;
			free(hTable->theLists);
			free(hTable);
			return NULL;
		} else {
			// 将节点元素中的所有值都赋值0
			memset(hTable->theLists[i], 0, sizeof(LinkNode));
		}
	}


	return hTable;
}	



// 从哈希表中根据键值查找元素
Element Find(HashTable *hTable, int key) {	// 参数一：哈希表；参数二：键值
	int i = 0;			// 保存键值对应的哈希桶的下标索引
	Link L = NULL;		// 保存对应哈希桶的头节点
	Element e = NULL;	// 用于循环遍历

	if (!hTable) {
		return NULL;
	}


	i = Hash(key, hTable->tableSize);	// 找到索引
	L = hTable->theLists[i];			// 将对应的哈希桶头节点赋值给L
	e = L->next;						// 从L的下一个节点开始查找

	// 结束条件：没有找到，返回NULL； 找到了，返回键值对应的节点
	while (e != NULL && e->key != key) {
		e = e->next;
	}

	return e;
}



// 哈希表插入元素，元素为键值对
void Insert(HashTable *hTable, int key, void *value) {	// 参数一：哈希表；参数二：键值；参数三：待插入的值
	int i = 0;				// 保存键值对应的哈希桶索引
	Link L = NULL;			// 保存键值对应的哈希桶的头节点
	Element e = NULL;		// 查找判断哈希表中是否已经存在相同的键值
	Element tem = NULL;		// new新对象插入
	

	if (!hTable || !value) {
		return;
	}

	// 查找判断哈希表中是否已经存在相同的键值
	e = Find(hTable, key);

	// 等于NULL说明没有哈希表中没有相同的键值，可以插入
	if (e == NULL) {

		// 为新插入的哈希元素分配内存
		tem = (Element)malloc(sizeof(LinkNode));		// 相当于 tem = new LinkNode;	
		if (!tem) {
			cout << "查找函数中的Element类型分配内存失败！" << endl;
			return;
		}

		// 保存值待插入
		tem->data = value;
		tem->key = key;

		i = Hash(key, hTable->tableSize);	// 获取索引
		L = hTable->theLists[i];			// 根据索引获取对应的哈希桶头节点

		// 使用头插法插入
		tem->next = L->next;
		L->next = tem;
	} else {
		cout << "插入失败，哈希表有重复的键值！" << endl;
	}
}	



// 哈希表删除元素，元素为键值对
void Delete(HashTable *hTable, int key) {	// 参数一：哈希表；参数二：键值
	int i = 0;					// 保存键值对应的哈希桶索引
	Link L = NULL;				// 保存键值对应的哈希桶的头节点
	Element e = NULL;			// 保存待删除节点
	Element last = NULL;		// 保存待删除节点的前一个节点
	
	if (!hTable) {
		return;
	}

	i = Hash(key, hTable->tableSize);
	L = hTable->theLists[i];
	e = L->next;
	last = L;	

	while (e != NULL && e->key != key) {
		last = e;		// last永远指向待删除节点的前一个节点
		e = e->next;
	}

	//如果键值对存在
	if (e != NULL) {
		last->next = e->next;
		delete e;
	}
}	


// 销毁哈希表
void Destroy(HashTable *hTable) {
	Link L = NULL;			// 保存哈希桶头节点
	Element cur = NULL;		// 用于遍历与释放
	Element next = NULL;	// 用于辅助遍历与释放

	if (!hTable) {
		return;
	}

	// 从零开始遍历哈希桶，直到遍历完为止
	for (int i = 0; i < hTable->tableSize; i++) {
		L = hTable->theLists[i];	// 获取第i个哈希桶
		cur = L->next;				// 从哈希桶的下一个节点开始遍历

		while (cur != NULL) {
			next = cur->next;		// next指向当前节点的下一个节点
			free(cur);				// 释放当前节点
			cur = next;				// cur获取自己的下一个节点
		}

		free(L);					// 释放当前第i的哈希桶内存
	}

	free(hTable->theLists);			// 释放存储哈希桶头节点的内存
	free(hTable);					// 释放哈希表

	cout << "释放成功" << endl;
}


/*哈希表元素中提取数据*/
void* Retrieve(Element e) {
	return e ? e->data : NULL;
}



int main(void) {
	//char *elem[] = { "迪丽热巴", "古力娜扎", "马尔扎哈" };
	char elem[][10] = { "迪丽热巴", "古力娜扎", "马尔扎哈" };
	HashTable *hTable = NULL;

	hTable = InitHashTable(16);

	// 默认第零个不存储元素
	Insert(hTable, 1, elem[0]);
	Insert(hTable, 2, elem[1]);
	Insert(hTable, 3, elem[2]);

	Delete(hTable, 1);


	for (int i = 0; i < 4; i++) {
		Element e = Find(hTable, i);
		if (e) {
			cout << (const char*)Retrieve(e) << endl;
		} else {
			cout << "没有找到！" << endl;
		}
		
	}

	Destroy(hTable);


	system("pause");
	return 0;
}

运行截图：
在这里插入图片描述
因为键值为零不存储元素，而且键值为一的元素已经被删除，所以运行结果才会由两个没有找到。这是正确的。

总结：
我个人感觉，只需要将哈希表的初始化搞懂了，他是如何分配内存的，是什么顺序分配内存，分配什么类型的内存。这些搞懂后，后面的查找、插入等，都是很简单的了。
笔者也是在哈希表的初始化那里卡了很久，一直没有搞懂他的分配内存，所以在哪里卡了很久，最总也还是吃透了。

cpp_learners
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++ 二叉树的垂直总和算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-14 7257
二叉树的垂直总和算法（Vertical Sum of a Binary Tree）是指计算二叉树中每个垂直列上节点值的和。垂直列指的是同一水平距离上的节点集合。具体来说，对于根节点位于坐标(0,0)的二叉树，左子树的坐标是(x-1,y-1)，右子树的坐标是(x+1,y-1)。
【C++】“最强查找“哈希表的底层实现
最新发布
Sxy_wspsby的博客
05-27 1651
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的比较次数。理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
树与二叉树 —— 十分钟吊打数据结构
qq_61500888的博客
04-08 2214
手撕树与二叉树结构 带你一命通关，分分钟拿捏数据结构。
二叉查找树与哈希表对比
weixin_42887343的博客
06-10 2540
速度对比： 哈希表的插入、删除、查找的时间复杂度都是 O(1)； 而平衡二叉查找树的插入、删除、查找的时间复杂度都是 O(logn)。 哈希表速度快，但缺点明显，被反杀： 散列表中的数据是无序存储的，如果要输出有序的数据，需要先进行排序。而对于二叉查找树来说，我们只需要中序遍历，就可以在 O(n) 的时间复杂度内，输出有序的数据序列。 散列表扩容耗时很多，而且当遇到散列冲突时，性能不稳定。而尽管二叉查找树的性能不稳定，但是在工程中，我们最常用的平衡二叉查找树的性能非常稳定，时间复杂度稳定在 O(lo
数组、线性表、二叉树、哈希表的对比
凯凯王的技术生涯
05-25 846
介绍哈希表之前,我们可以了解下其他结构在新增、查找等基础操作的执行性能 - 数组：一段连续的存储单元来存储数据。指定下标的查找，时间复杂度为O(1)；通过给定值的查找，需要遍历数组，逐一对比给定关键字和数组元素，时间复杂度为O(n),当然，对于有序数组，则可采用二分查找，插值查找，可将复杂度提高到O(logn)。对于一般的插入和删除操作，牵扯到元素的移动，其平均复杂度也为O(n) - 线性链表：对于链表的新增、删除等操作，仅需处理节点间的引用即可，时间复杂度为O(n),而查找操作需要遍历链表进行逐一比对，复
myicq-1.0a1服务器代码的一点分析(二)—在线人员管理与内存分配
顾剑辉的专栏
11-29 2119
myicq-1.0a1服务器代码的一点分析(二)—在线人员管理与内存分配顾剑辉(Solarsoft)http://solarsoft.126.com在线人员的管理在upd服务器中,在线人员的管理是必不可少的.其实这种方法也可以用到游戏服务器中.接下去我们来看一下,myicq是怎样管理的.Myicq采用的是哈希表来管理,哈希表的查找效率是非常高的,到目前是我见的最高效的查找方
高级数据结构 | 树和二叉树
专注于C/C++/Linux领域创作
04-07 333
树的定义： 树是由 n (n>= 0)个结点组成的有限集合。如果 n = 0，称为空树；如果 n > 0，则 有一个特定的称之为根(root)的结点，它只有直接后继，但没有直接前驱； 除根以外的其它结点划分为 m (m >= 0)个互不相交的有限集合 T0, T1, …, Tm-1，每个集合又是一棵树，并且称之为根的子树(subTree)。每棵子树的根结点有且仅有一个直接前驱，...
C++股票信息查询系统源代码，实现多种查询排序算法KMP算法、二叉树、哈希表等，C++课程设计
02-13
这个系统采用了一系列高级编程技术，如KMP算法、二叉树和哈希表，以高效地处理股票信息查询。下面我们将详细探讨这些关键知识点。 1. **KMP算法**： KMP（Knuth-Morris-Pratt）算法是一种字符串匹配算法，用于在一...
C／C++常用算法手册（带详细书签目录）
06-28
《C/C++常用算法手册》是一本专门为C和C++编程者设计的算法参考书籍，旨在帮助读者理解和掌握各种常见的算法。这本书包含了丰富的算法实例，每个算法都配有详细的分析和解释，使得学习过程更为直观易懂。对于C++算法...
c/c++常用算法手册随书代码
12-19
《C/C++常用算法手册随书代码》是一个非常宝贵的资源，它包含了大量C++编程中的经典算法实现。这本书的代码库旨在帮助读者更好地理解和实践各种算法，加深对C++编程语言的理解，提升解决实际问题的能力。以下是根据...
C编写的查表程序
07-26
用C语言编写的查表程序，用于采样或空间换时间参考。
程序员算法大全算法数据结构智力题 C/C++
04-06
数据结构则是组织和管理数据的方式，包括数组、链表、栈、队列、树（如二叉树、AVL树、红黑树）、哈希表、图等。选择合适的数据结构能极大地优化算法性能，比如哈希表的查找速度可以达到O(1)，而链表则适合频繁的...
【数据结构与算法】二叉树+二叉搜索树+平衡二叉树+红黑树--效率比较
kevin的博客
05-28 1342
分析方法： [ 二叉树用到递归，与二叉树高度有关，有多高，就有多少次递归，时间复杂度就是"O(树高)" 二叉树的高度与节点关系： 假设节点为N，则树的高度保持在logN附近；所以二叉树的查找效率一般是O(logN) ] 1二叉树 --任意的 2二叉搜索树： --是二叉树经过排序的，任意一个节点都满足左节点值小于等于父节点，右节点值大于等于父节点 [ 又称二叉查找树，亦称为二叉排序树 查找性能： [ 数目为N，树高保持logN附近，查找递归需要logN次，时间复杂度为O(logN) 当先...
常见数据结构与算法个人总结-（二叉树、哈希表）
weixin_55435895的博客
08-30 219
二叉树 二叉树跟树的区别在于，子节点最多只有两个，这就很好地让我们有遍历的方法。 遍历的想法： 只要把每一个二叉树的根子节点和下面相邻一层的左右子树独立出来，就能很快遍历了。跟着做一遍，可以很快学会二叉树的三种遍历。 先序遍历：口诀，先左划一条线，然后慢慢找，左边弄完右边独立循环。 所遍历的从根节点出发，先走左字树，吧所有的根子节点看成一个根节点，等于说二叉树只看到当前子节点下面的两个子节点。本着先左后右的原则遍历，当走到最底层的左子节点的时候，返回到当前的上一个根子节点，然后再遍历完当前的右.
【C++进阶】哈希表详解
m0_67077469的博客
03-21 2586
哈希表详解
C++ 数据结构实战：快速查找
Yummy
03-27 3566
最近线上开发C++时，遇到一个性能问题，业务场景简单描述为： 给定m个商品ID, 4个特征(特征数量可增可减)，已知商品对应的每个特征的值，如何快速获取某个商品的某个特征值？ 当时我采取的是stl嵌套的数据结构，由于时间复杂度较高，且vector的值是随着map的rehash阶段不断进行内存拷贝的, 在全量计算特征的时候会给性能造成很大的压力，当时与base的性能对比如下： 性能不...
C++实现二叉树结构及其二叉树常用算法
weixin_45189666的博客
05-09 3596
文章目录头文件成员函数构造函数创建二叉树CreateBTNode输出二叉树DispBTree查找指定节点FindNode查找左、右孩子节点求树高BTreeHeight递归遍历非递归遍历前序遍历 头文件 使用node 定义节点，并重命名为BTNode。二叉树类 BTree中含有一个成员BTNode* head;存放二叉树的头节点。 typedef int ElemType; const int MaxSize = 20; //二叉树链式存储结构 typedef struct node { ElemT
各种数据结构性能的比较
jh19900712的专栏
04-30 7813
数据结构包括数组、链表、栈、二叉树、哈希表等等
数据结构实现—查找的平均效率比较（CC++）
jdjhsj的博客
11-17 434
数据结构实现—查找的平均效率比较（C/C++）
C/C++算法实现：数论与图论算法详解
- 数据结构：包括链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图、哈希表等，它们为算法提供了存储和操作数据的结构。 - 动态规划：解决最优化问题的一种方法，通过将问题分解成子问题来避免重复计算。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpp_learners

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值