数据结构与算法——散列表的实现

最新推荐文章于 2022-05-13 15:24:06 发布
最新推荐文章于 2022-05-13 15:24:06 发布
阅读量753 收藏 2
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39661206/article/details/90383871
版权

1、数组的方式实现散列表

1.1头文件

#ifndef _HASHTABLE_H
#define _HASHTABLE_H

enum StateType {Empty, Deleted, Active};
struct HashItem
{
	int data;
	StateType info;
	HashItem()
	{
		info = Empty;
	}
	HashItem(int InputData):data(InputData)
	{
		info = Active;
	}
	bool operator ==(const int& InputData)
	{
		return data == InputData;
	}
	bool operator !=(const int& InputData)
	{
		return data != InputData;
	}
};

class HashTable
{
public:
	HashTable();
	~HashTable();
	HashTable(const int len);
	bool Insert(const int data);
	bool Delete(const int data);
	bool Contain(const int data);
	int  Count();
	void print();
private:
	int Hash(int key);
private:
	int module;
	HashItem *pHash;
	int nCount;
};
#endif //_HASHTABLE_H

1.2 源文件

/*
* Copyright: (c) 2019
*
* 文件名称:  HashTable.cpp	
* 文件标识：
* 摘	要：该散列表不能存放重复数据
*
* 版	本： 1.0
* 作	者： RF_LYF
* 创建日期:	 2019/5/9  22:29
*/

#include "HashTable.h"
#include <iostream>
using namespace std;
HashTable::HashTable()
{
	module = 17;
	pHash = new HashItem[module];
	nCount = 0;
}

HashTable::HashTable(const int len):module(len)
{
	pHash = new HashItem[module];
	nCount = 0;
}

HashTable::~HashTable()
{
	delete []pHash;
	pHash = NULL;
}

/**
* @brief
*
* @method:    Insert
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  10:38 
*/
bool HashTable::Insert(const int data)
{
	if(nCount == module)
		return false;
	else
	{
		nCount++;
		int index = Hash(data);
		while(pHash[index].info != Empty && pHash[index].info != Deleted)
		{
			index = Hash(index + 1);
		}
		pHash[index] = data;
		return true;
	}
}

/**
* @brief
*
* @method:    Delete
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  10:38 
*/
bool HashTable::Delete(const int data)
{
	int index = Hash(data);
	while(pHash[index] != data)
	{
		index = Hash(index + 1);
		if(pHash[index].info == Empty || index == Hash(data))
			return false;//数据不存在
	}
	pHash[index].info = Deleted;
	nCount--;
	return true;
}

/**
* @brief
*
* @method:    Count
* @access:    public 
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  10:20 
*/
int  HashTable::Count()
{
	return nCount;
}

/**
* @brief
*
* @method:    Contain
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  10:25 
*/
bool HashTable::Contain(const int data)
{
	if(pHash[Hash(data)] == data)
		return true;
	else
	{
		int index = Hash(data);
		while(pHash[index] != data)
		{
			index = Hash(index + 1);
			if(pHash[index].info == Empty || index == Hash(data))
				return false;
		}
		return true;
	}
}


/**
* @brief      除留法
*
* @method:    Hash
* @access:    private 
* @param:     int key
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  10:11 
*/
int HashTable::Hash(int key)
{
	return key % module;
}


/**
* @brief	  用来测试程序
*
* @method:    print
* @access:    public
* @Return:    void
* @author:    RF_LYF
* @since:   2019/5/10  14:24 
*/
void HashTable::print()
{
	for(int i = 0; i < module; ++i)
	{
		if(pHash[i].info != Empty && pHash[i].info != Deleted)
			cout << pHash[i].data << endl;
	}
}

2、链表的方式实现散列表

2.1 头文件

#ifndef _HASHTABLELIST_H
#define _HASHTABLELIST_H
#include <list>
enum StateType {Empty, Deleted, Active};
struct HashItem
{
	int data;
	StateType info;
	HashItem()
	{
		info = Empty;
	}
	HashItem(const int& InputData)
	{
		data = InputData;
		info = Active;
	}
};
class HashTableList
{
public:
	HashTableList(void);
	HashTableList(int nLen);
	~HashTableList(void);
	bool Insert(const int& data);
	bool Delete(const int& data);
	bool Contain(const int& data);
	int Count();
	void print();
private:
	int Hash(int key);
	void erase();
	
	typedef std::list<HashItem>* NodeType;
private:
	int module;
	NodeType *pHeadArr;
	int nCount;
};

#endif // _HASHTABLELIST_H

2.2 源文件

#include "HashTableList.h"
#include <iostream>
#include <string.h>
using namespace std;

HashTableList::HashTableList(void)
{
	module = 17;
	nCount = 0;
	pHeadArr = new NodeType[module];
	memset((void *)pHeadArr, 0, module*sizeof(NodeType));
}


HashTableList::~HashTableList(void)
{
	erase();
}


HashTableList::HashTableList(int nLen):module(nLen)
{
	nCount = 0;
	pHeadArr = new NodeType[module];
	memset((void *)pHeadArr, 0, module*sizeof(NodeType));
}


/**
* @brief
*
* @method:    Insert
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  11:51 
*/
bool HashTableList::Insert(const int& data)
{
	int index = Hash(data);
	if(pHeadArr[index] == NULL)
	{
		pHeadArr[index] = new list<HashItem>();
	}
	HashItem *pTemp = new HashItem(data);
	pHeadArr[index]->push_back(*pTemp);
	delete pTemp;
	++nCount;
	return true;
}


/**
* @brief
*
* @method:    Delete
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  12:03 
*/
bool HashTableList::Delete(const int& data)
{
	if(pHeadArr[Hash(data)] == NULL)
		return false;
	else
	{
		int index = Hash(data);
		list<HashItem>::iterator it = pHeadArr[index]->begin();
		for(; it != pHeadArr[index]->end(); ++it)
		{
			if(it->data == data)
			{
				pHeadArr[index]->erase(it);
				--nCount;
				return true;
			}
		}
		return false;
	}
}


/**
* @brief
*
* @method:    Contain
* @access:    public 
* @param:     int data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/10  11:58 
*/
bool HashTableList::Contain(const int& data)
{
	if(pHeadArr[Hash(data)] == NULL)
		return false;
	else
	{
		int index = Hash(data);
		list<HashItem>::iterator it = pHeadArr[index]->begin();
		for(; it != pHeadArr[index]->end(); ++it)
		{
			if(it->data == data)
				return true;
		}
		return false;
	}
}


/**
* @brief
*
* @method:    Count
* @access:    public 
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  11:25 
*/
int HashTableList::Count()
{
	return nCount;
}


/**
* @brief
*
* @method:    Hash
* @access:    private 
* @param:     int key
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  11:27 
*/
int HashTableList::Hash(int key)
{
	return key % module;
}


/**
* @brief
*
* @method:    erase
* @access:    private 
* @Return:    void
* @author:    RF_LYF
* @since:   2019/5/10  13:48 
*/
void HashTableList::erase()
{
	for(int i = 0; i < module; ++i)
	{
		if(pHeadArr[i] != NULL)
		{
			delete pHeadArr[i];
			pHeadArr[i] = NULL;
		}
	}
	delete []pHeadArr;
	pHeadArr = NULL;
}


void HashTableList::print()
{
	for(int i = 0; i < module; ++i)
	{
 		if(pHeadArr[i] != NULL)
 		{
 			list<HashItem>::iterator it = pHeadArr[i]->begin();
 			for(; it != pHeadArr[i]->end(); ++it)
 				cout << it->data << " ";
 		}
		cout << endl;
	}
}

3、支持动态扩容的散列表——数组方式实现

3.1 头文件

/*
* Copyright: (c) 2019
*
* 文件名称:  HashTableOpti.h	
* 文件标识：
* 摘	要：
*
* 版	本： 1.0
* 作	者： RF_LYF
* 创建日期:	 2019/5/10  16:36
*/

#ifndef _HASHTABLEOPTI_H
#define _HASHTABLEOPTI_H
enum StateType {Empty, Active, Deleted};
struct HashItem
{
	int data;
	StateType info;
	HashItem()
	{
		info = Empty;
	}
	HashItem(const int& InputData)
	{
		data = InputData;
		info = Active;
	}
	bool operator == (const int& InputData)
	{
		return data == InputData;
	}
	bool operator != (const int& InputData)
	{
		return data != InputData;
	}
};
class HashTableOpti
{
public:
	HashTableOpti(void);
	HashTableOpti(const int& nLen, const double& f);
	~HashTableOpti(void);

	bool Insert(const int& data);
	bool Delete(const int& data);
	bool Contain(const int& data);
	int Count();
	void print();
private:
	int Hash(int key, int mod);
	void Expand();
	bool ArrEmpty();
	int Find(const int& data, bool& inOldArr);
	void InsertAssist(const int &data);
	int FindValidDataInOldArr();
private:
	int module;
	int moduleOld;
	int nCount;
	int nCountOld;
	HashItem* pHash;
	HashItem* pHashOld;
	double factor;
};

#endif //_HASHTABLEOPTI_H

3.2 源文件

#include "HashTableOpti.h"
#include <iostream>
using namespace std;

HashTableOpti::HashTableOpti(void)
{
	module = 17;
	moduleOld = 0;
	nCount = 0;
	nCountOld = 0;
	pHash = new HashItem[module];
	pHashOld = NULL;
	factor = 0.75;
}


HashTableOpti::HashTableOpti(const int& nLen, const double& f):
module(nLen), factor(f)
{
	moduleOld = 0;
	nCount = 0;
	nCountOld = 0;
	pHash = new HashItem[module];
	pHashOld = NULL;
}


HashTableOpti::~HashTableOpti(void)
{
	delete []pHash;
	pHash = NULL;
	if(pHashOld != NULL)
	{
		delete []pHashOld;
		pHashOld = NULL;
	}
}


/**
* @brief
*
* @method:    Insert
* @access:    public 
* @param:     const int & data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/20  11:27 
*/
bool HashTableOpti::Insert(const int& data)
{
	double ret = (double)nCount / module;
	if(ret >= factor)
	{
		Expand();
	}
	int temp = FindValidDataInOldArr();
	if(temp >= 0)
	{
		InsertAssist(pHashOld[temp].data);
		ArrEmpty();
	}
	InsertAssist(data);
	return true;
}


/**
* @brief
*
* @method:    FindValidDataInOldArr
* @access:    private 
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/20  14:37 
*/
int HashTableOpti::FindValidDataInOldArr()
{
	if(pHashOld == NULL)
		return -1;
	else
	{
		for(int i = 0; i < moduleOld; ++i)
		{
			if(pHashOld[i].info != Empty && pHashOld[i].info != Deleted)
			{
				pHashOld[i].info = Deleted;
				return i;
			}
		}
		return -1;
	}
}


/**
* @brief
*
* @method:    InsertAssist
* @access:    private 
* @param:     const int & data
* @Return:    void
* @author:    RF_LYF
* @since:   2019/5/20  14:39 
*/
void HashTableOpti::InsertAssist(const int &data)
{
	int index = Hash(data, module);
	while(pHash[index].info != Empty && pHash[index].info != Deleted)
	{
		index = index + 1;
	}
	pHash[index].data = data;
	pHash[index].info = Active;
	nCount++;
}


/**
* @brief
*
* @method:    ArrEmpty
* @access:    private 
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/20  12:02 
*/
bool HashTableOpti::ArrEmpty()
{
	if(--nCountOld == 0)
	{
		delete []pHashOld;
		pHashOld = NULL;
		return true;
	}
	return false;
}


/**
* @brief
*
* @method:    Find
* @access:    private 
* @param:     const int & data
* @param:     bool & inOldArr
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/20  12:03 
*/
int HashTableOpti::Find(const int& data, bool& inOldArr)
{
	int nFlag = -1;
	if(pHashOld)
	{
		int index = Hash(data, moduleOld);
		while(pHashOld[index].info != Empty)
		{
			if(pHashOld[index] == data)
			{
				nFlag = index;
				inOldArr = true;
				break;
			}
			index = index + 1;
		}
	}
	if(nFlag < 0)
	{
		int index = Hash(data, module);
		while(pHash[index].info != Empty)
		{
			if(pHash[index] == data)
			{
				nFlag = index;
				inOldArr = false;
				break;
			}
			index = index + 1;
		}
		return nFlag;
	}
	else
	{
		return nFlag;
	}	
}


/**
* @brief
*
* @method:    Delete
* @access:    public 
* @param:     const int & data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/20  13:41 
*/
bool HashTableOpti::Delete(const int& data)
{
	bool bFlag = false;
	int ret = Find(data, bFlag);
	if(ret >= 0 && bFlag)
	{
		pHashOld[ret].info = Deleted;
		ArrEmpty();
		return true;		
	}
	else if(ret >= 0 && !bFlag)
	{
		pHash[ret].info = Deleted;
		--nCount;
		return true;
	}
	else
		return false;
}


/**
* @brief
*
* @method:    Contain
* @access:    public 
* @param:     const int & data
* @Return:    bool
* @author:    RF_LYF
* @since:   2019/5/20  14:39 
*/
bool HashTableOpti::Contain(const int& data)
{
	bool bFlag = false;
	int ret = Find(data, bFlag);
	if(ret < 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}


/**
* @brief
*
* @method:    Count
* @access:    public 
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  16:53 
*/
int HashTableOpti::Count()
{
	return nCount + nCountOld;
}


void HashTableOpti::print()
{
	if(pHashOld)
	{
		cout << "member in Old Array is :" << endl;
		for(int i = 0; i < moduleOld; ++i)
		{
			if(pHashOld[i].info != Empty && pHashOld[i].info != Deleted)
			cout << pHashOld[i].data << " ";
		}
		cout << endl;
	}
	cout << "member in Current Array is :" << endl;
	for(int i = 0; i < module; ++i)
	{
		if(pHash[i].info != Empty && pHash[i].info != Deleted)
			cout << pHash[i].data << " ";
	}
	cout << endl;
}


/**
* @brief
*
* @method:    Hash
* @access:    private 
* @param:     int key
* @Return:    int
* @author:    RF_LYF
* @since:   2019/5/10  17:14 
*/
int HashTableOpti::Hash(int key, int mod)
{
	return key % mod;
}


/**
* @brief
*
* @method:    Expand
* @access:    private 
* @Return:    void
* @author:    RF_LYF
* @since:   2019/5/20  14:46 
*/
void HashTableOpti::Expand()
{
	moduleOld = module;
	module *= 2;
	pHashOld = pHash;
	nCountOld = nCount;
	nCount = 0;
	pHash = new HashItem[module];
}

 

Asher@福
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（五）算法与数据结构|“散列表”结构
白衬衫猿
03-16 285
散列表和数组有一个相同的特性——按下标随机访问。散列表是数组的一种扩展，由数组演化而来。 散列表的下标叫键（key）或关键字。通过散列函数（也叫哈希函数、hash函数）把键转化为元素，得到的结果叫散列值（value）（也叫哈希值、hash值）。 hash(key)==&amp;amp;gt;value 散列函数基本设计要求 散列函数计算得到的散列值为非负整数。因为散列值用来作为下标随机访问散列表。 若key1...
数据结构——散列表
码农少年专栏
12-15 354
什么是散列表 散列表也叫做哈希表（hash table），这种数据结构提供了键和值的映射关系。根据key可以快速的查找他所匹配的value，时间复杂度接近于O(1)。 散列表的实现 散列表本质上就是一个数组，这也是为啥散列表为啥查找速度快。 数组的下标是0，1，2，3....这样的，散列表的key一般都是字符串类型的，所以我们需要一个“中转站”，通...
哈希表（散列表）简单实现
ylf13的专栏
10-14 1315
来自百度 若结构中存在关键字和K相等的记录，则必定存储在f(K）的位置上。由此，不需比较便可直接取得所查记录。这个对应关系f称为散列函数(Hash function），按这个思想建立的表为散列表。 * 对不同的关键字可能得到同一散列地址，即key1≠key2，而f(key1)=f(key2），这种现象称冲突。具有相同函数值的关键字对该散列函数来说称做同义词。 * 综上所述，根
数据结构篇九：散列表
Dzp199903的博客
03-24 242
散列表 1.什么是散列表？ 散列表就是通过一个映射函数，把每个数据映射为一个数组下标，按照下标存储起来，当我们访问这个数据时，只需要通过映射函数计算出下标，就可以找到这个数。 2.散列表映射函数 从散列表定义来看，散列表最重要的是设计映射函数，映射函数决定效率和减少地址冲突，常见的映射函数有下面的几个。。。 直接定址法 数学分析法 除留取余法 随机数法 3.散列表的冲突问题 不管我们设计的散列函数多牛逼。都无法避免数据映射冲突问题，冲突就是两个数据经过映射函数处理后得到的数据是一样的。这个时候不可能把它
算法---散列表
yinhua405的博客
05-03 269
如果能在关键字与记录保存的位置之间建立一种联系，则可以不经过比较，直接对关键字进行计算得出记录的位置，再到相应位置去读取数据即可。 将这种关键字与记录保存位置之间的对应关系称为散列函数，将这种方式建立的表称为散列表。 #include #define HASH_LEN 13 #define TABLE_LEN 8 int data[TABLE_LEN] = {69,65,
链接法散列表python实现
qq_35404894的博客
07-15 307
链接法散列表 python实现 具有关键字k的节点，通过散列函数h， 把节点存放在散列表T[0…m-1]的槽h(k)内，h(k)为散列值，但是存在一个问题，不同的关键字可能有相同的散列值，存放在散列表内会发生冲突，因此，可以通过链接法，通过在每个槽内存放一个指向双向链表或单向链表的指针，把具有相同散列值的节点存放在一条链表内从而解决冲突。 class Node(object): def __init__(self, key): self.key = key self
Python数据结构——散列表
weixin_34023982的博客
06-22 520
散列表的实现常常叫做散列(hashing)。散列仅支持INSERT,SEARCH和DELETE操作，都是在常数平均时间执行的。需要元素间任何排序信息的操作将不会得到有效的支持。 散列表是普通数组概念的推广。如果空间允许，可以提供一个数组，为每个可能的关键字保留一个位置，就可以运用直接寻址技术。 当实际存储的关键字比可能的关键字总数较小时，采用散列表就比较直接寻址更为有效。在散列表中，不是直接把...
HashMap 实现原理与源码分析
十指波课堂的博客
08-07 94
逐步来认识HashMap1、数组public class Array { /** * 删除 插入 慢 O(n) * 找到下标的查找 O(1) * java.util.ArrayList * @param args */ public static void main(String[] args) { Integer...
数据结构—散列表及HashMap的put方法和扩容机制
TPH_BETTER.的博客
03-28 1085
定义 散列表：散列表(也叫哈希表)，就是把任意长度值(key)通过散列算法变换成固定长度的key(地址)通过这个地址进行访问的一种数据结构 也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找记录的速度。而这个映射函数叫做散列函数，存放记录的数组叫做散列表。 哈希函数 哈希碰撞 通过哈希算法之后映射到散列表的位置上但已经有值的时候，就称为哈希碰撞。 哈希碰撞解决办法 JDK1.7:采用链表引用 JDK1.8:链表引用+红黑树 红黑树查询的原理：红黑树又
015查找、排序、符号表、散列表等算法实现（1）
m0_37692918的博客
01-20 243
基本的查找、排序、符号表、散列表算法实现汇总1本文参考《算法(第4版)》基本的查找、排序算法汇总1.比较和交换2.选择排序3.插入排序4.希尔排序5.归并排序6.快速排序7.三向快速排序8.归并排序9.堆排序和基于堆排序的优先队列10.基于有序数组的二分查找实现符号表11.二叉树12.基于拉链的散列表13.基于线性探索的散列表 本文参考《算法(第4版)》 基本的查找、排序算法汇总 1.比较和交换 ...
数据结构与算法详解——散列表篇（附c++实现代码）
JMasker的博客
05-13 1912
目录散列表散列函数哈希冲突开放地址法线性探测二次探测双重散列链表法装载因子 散列表   前面数组、链表、栈、队列都是序列式容器，存储的都是一个元素。而散列表又叫哈希表(hash table)，是一种关联式容器，存储的是一对值，一般是一个key对应一个value(又叫键值对)。   c++ stl中的map就是一个散列表，举个例子： std::map<std::string,int> m; m["小明"]=170; std::cout<<"小明的身高是"<<m["小明"]&
数据结构: 散列表实现思路和实例
doomwatcher的博客
02-08 1983
前言 ★ 这里是小冷的博客 ✓ 优质技术好文见专栏 个人公众号，分享一些技术上的文章，以及遇到的坑 当前系列：数据结构系列 源代码 git 仓库 ‘ 数据结构代码地址 代码Git 仓库地址 目录前言哈希表哈希表的基本介绍google 上机题思路分析并画出示意图思路实现效果演示新增与遍历查找 哈希表 哈希表的基本介绍 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通 过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映
Solr在JAVA项目中的详细配置
西瓜咬人啦
10-17 249
1. 项目架构 zookper + dubbo+springboot API提供接口 service属于生产者，业务逻辑实现 web属于消费者 2. 开发核心jar redis和solr启动客户端的jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</a.
C语言写一个散列表
微小冷的学习笔记
12-30 2592
文章目录快速理解散列表散列函数防撞 快速理解散列表 散列表，就是下标可以为字母的数组。 假设现有一个数组int a[100]，想查找其中第40个元素，则直接输入a[40]就可以了，时间复杂度为O(1)O(1)O(1)。 问题在于，当下标不是数字，而是一个字符串的时候，可能需要一个超大的空间才能将所有下标妥善地存放在特定的位置。例如，若以大小写字母作为下标索引，那么一位就需要预留52个空间，10位就需要521052^{10}5210这么大的空间，根本没有设备可以满足。 好在，521052^{10}5210这么
散列表的基本原理与实现
weixin_30307921的博客
05-19 1096
本篇博文主要介绍散列表（Hash Table）这一常见数据结构的原理与实现。由于个人水平有限，文章中难免存在不准确或是不清晰的地方，希望大家可以指正：） 一、概述 符号表是一种用于存储键值对（key-value pair）的数据结构，我们平常经常使用的数组也可以看做是一个特殊的符号表，数组中的“键”即为数组索引，值为相应的数组元素。也就是说，当符号表中所有的键都是较小的整数时...
散列表的实现
漠漠水田飞白鹭
10-08 860
一,线性探测法 核心:冲突的时候线性的向下寻找可用空间; 缺点:对同一散列地址的争夺现象会出现堆积;   二,二次探测法 核心:冲突的时候探测下面的+_k^2; 缺点：不易探测到整个散列表的所有空间；   三,链地址法 同一地址放置一条链
算法图解——散列表
clear-ninghongkang的博客
12-14 910
散列表的内部机制：实现、冲突和散列函数。 散列的概念属于查找，采用直接寻址技术。在理想情况下，查找的时间为O(1)。 散列函数 散列函数 ：将输入映射到数字 散列函数满足的要求： 1.一致性 2.不同的输入映射到不同数字 3.同样的输入映射到相同的索引 4.不同的输入映射到不同的索引 5.散列函数知道数组的大小...
Python数据结构与算法分析（第二版）答案 - 第五章（仅供参考）
m0_62401440的博客
04-24 5812
本人手写或借阅资料，仅供参考，有错误欢迎指正。 本章需调用第三章课后作业部分内容 import random from homework.homework3 import UnorderedList import timeit #5.1 进行随机实验，测试顺序搜索算法与二分搜索算法在处理整数列表时的差异 #顺序搜索 def sequentialsearch(ml, v): pos = 0 found = False while pos < len(ml) and n
Hash表的简单实现
jiuweideqixu的博客
06-07 1714
Hash表的定义 哈希表(Hash table，也叫散列表)，是根据关键字值(key)直接进行访问的数据结构，它通过把关键字值 映射到表中一个位置 (数组下标 )来直接访问，以加快查找 关键字值的速度。这个映射函数叫做 哈希(散列)函数，存放记录的数组 叫做哈希 ( )(散列)表。 给定表M，存在函数f(key)，对任意的关键字值key，代入函数后若能得到包含该 关键字的表中地址，称表M为哈希(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值