山东大学数据结构与算法实验8散列表（线性开型寻址/链表散列）

最新推荐文章于 2024-09-28 09:18:19 发布
最新推荐文章于 2024-09-28 09:18:19 发布
阅读量858 收藏 11
点赞数 13
分类专栏： 山东大学 数据结构与算法 文章标签： 散列表 链表 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Water_Star1/article/details/140566489
版权

A : 线性开型寻址

题目描述

要求

使用线性开型寻址实现

描述

给定散列函数的除数 D 和操作数 m，输出每次操作后的状态。
有以下三种操作：

  1. 插入 x，若散列表已存在 x，输出“Existed”，否则插入 x 到散列表中，输出所在的下标。
  2. 查询 x，若散列表不含有 x，输出“-1”，否则输出 x 对应下标。
  3. 删除 x，若散列表不含有 x，输出“Not Found”，否则输出删除 x 过程中移动元素的个数。

实验目的

1、掌握散列表结构的定义和实现。

2、掌握散列表结构的应用。

输入输出格式

输入：

第一行两个整数D，m。分别代表散列函数的除数D和操作数m。

接下来m行，每行两个整数opt和x，分别代表操作类型和操作数。

若opt为0，代表插入x；

若opt为1，代表查询x；

若opt为2，代表删除x。

输出：

按需输出。

数据结构与算法描述  

先构造一个散列表类，插入函数先判断该数散列表中是否存在，如果不存在则从插入数的起始桶开始遍历，找到空桶后插入。

class hashTable {
private:
	int divisor;//除数
	int* table;//散列表
public:
	hashTable(int thedivisor ) {
		divisor = thedivisor;
		table = new int[divisor];
		for (int i = 0; i < divisor; i++) {//初始化为-1
			table[i] = -1;
		}
	}
	~hashTable() { delete[] table; }
	void insert(int x); 
	void find(int x);
	void deletes(int x);
};
void hashTable::insert(int x) {//插入
	for (int i = 0; i < divisor; i++) {//是否存在
		if (x == table[i]) {
			cout << "Existed" << endl;
			return;
		}
	}
	int s;
	s = x % divisor;//起始桶
	int i = s;
	do {
		if (table[i] == -1) {//找到空桶插入，输出下标
			table[i] = x;
			cout << i << endl;
			break;
		}
		else {
			i = (i + 1) % divisor;
		}
	} while (i != s);
}

查询函数从输入数的起始桶开始编列判断是否有。

void hashTable::find(int x) {//查询
	int s = x % divisor;//起始桶
	int j = s;
	int b = 0;//判断是否有x
	do {
		if (table[j] == x) {//有输出下标
			cout << j << endl;
			b = 1;
			break;
		}
		else {
			j = (j + 1) % divisor;
		}
	} while (j != s && table[j] != -1);
	if (b==0) {//没有输出-1
		cout << -1 << endl;
	}
}

删除函数，先判断散列表中是否存在，如果存在将要删除的数改为-1，并记录删除的位置。从删除的位置的下一个开始循环遍历。如果遇到空桶则直接跳出循环，如果是一下几种情况则用continue结束本轮循环，进行下一个循环。（1）遍历到的数恰好在起始桶；（2）删除的遍历到的数的起始桶在删除空位之后，且遍历到的数位置在自己的起始桶之后；（3）遍历的位置在删除空位的前面，遍历的位置在删除数的起始桶前；（4）删除数的起始桶在删除的空位后，删除的空位在遍历的数前。

void hashTable::deletes(int x) {//删除
	int s = x % divisor;//起始桶
	int j = s;
	int b = 0;//判断是否存在
	do {
		if (table[j] == x) {//如果存在删除x，即改为-1
			table[j] = -1;
			b = 1;
			break;
		}
		else {
			j = (j + 1) % divisor;
		}
	} while (j != s && table[j] != -1);
	if (b==0) {//如果没有输出 "Not Found"
		cout << "Not Found" << endl;
		return;
	}
	s = j;//删除后的空位（-1处）
	j = (j + 1) % divisor;//删除的下一个位置
	int k = s;//删除数的下标
	int sum = 0;
	for (int i = j; i != (j + divisor-1)%divisor; i=(i+1)%divisor) {//从删除的下一个位置，遍历整个散列表
		if (table[i] == -1) {//遇到空桶直接跳出循环
			break;
		}
		int x2 = table[i];//遍历到的数
		if (i == (x2 % divisor) || ((x2%divisor)> s)&&i> (x2 % divisor)) {
			continue;//当该数恰好在起始桶||删除的遍历到的数的起始桶在删除空位之后，且x2在起始桶之后
		}
		else {
			if ( i < s&& i>(x2 % divisor)) {
				continue;//遍历的位置在删除空位的前面，遍历的位置在删除数的起始桶前
			}
			if ((x2 % divisor) > s && s > i) {
				continue;//删除数的起始桶在删除的空位后，删除的空位在遍历的数前
			}
			int a = i;
			sum++;//除了以上的情况都要移动所以++
			while (table[(a + divisor-1) % divisor]!=-1  ) {
				a = (a + divisor - 1) % divisor;//从i开始向前遍历，直到有空位置
			}
			table[(a + divisor - 1) % divisor] = x2;//移动到该空位置
			table[i] = -1;//原位置改为空
			s = i;//将删除后空的位置改为此处
		}
	}
	cout << sum << endl;//循环结束输出统计的移动个数
}

除了以上几种情况都要移动，从遍历所在的位置一次向前找到空位插入，并将删除后的空位置改为此处被移动的原位置。整个循环结束后输出统计的移动的个数。

测试结果

完整代码（含注释）

#include<iostream>
using namespace std;
class hashTable {
private:
	int divisor;//除数
	int* table;//散列表
public:
	hashTable(int thedivisor ) {
		divisor = thedivisor;
		table = new int[divisor];
		for (int i = 0; i < divisor; i++) {//初始化为-1
			table[i] = -1;
		}
	}
	~hashTable() { delete[] table; }
	void insert(int x); 
	void find(int x);
	void deletes(int x);
};
void hashTable::insert(int x) {//插入
	for (int i = 0; i < divisor; i++) {//是否存在
		if (x == table[i]) {
			cout << "Existed" << endl;
			return;
		}
	}
	int s;
	s = x % divisor;//起始桶
	int i = s;
	do {
		if (table[i] == -1) {//找到空桶插入，输出下标
			table[i] = x;
			cout << i << endl;
			break;
		}
		else {
			i = (i + 1) % divisor;
		}
	} while (i != s);
}
void hashTable::find(int x) {//查询
	int s = x % divisor;//起始桶
	int j = s;
	int b = 0;//判断是否有x
	do {
		if (table[j] == x) {//有输出下标
			cout << j << endl;
			b = 1;
			break;
		}
		else {
			j = (j + 1) % divisor;
		}
	} while (j != s && table[j] != -1);
	if (b==0) {//没有输出-1
		cout << -1 << endl;
	}
}
void hashTable::deletes(int x) {//删除
	int s = x % divisor;//起始桶
	int j = s;
	int b = 0;//判断是否存在
	do {
		if (table[j] == x) {//如果存在删除x，即改为-1
			table[j] = -1;
			b = 1;
			break;
		}
		else {
			j = (j + 1) % divisor;
		}
	} while (j != s && table[j] != -1);
	if (b==0) {//如果没有输出 "Not Found"
		cout << "Not Found" << endl;
		return;
	}
	s = j;//删除后的空位（-1处）
	j = (j + 1) % divisor;//删除的下一个位置
	int k = s;//删除数的下标
	int sum = 0;
	for (int i = j; i != (j + divisor-1)%divisor; i=(i+1)%divisor) {//从删除的下一个位置，遍历整个散列表
		if (table[i] == -1) {//遇到空桶直接跳出循环
			break;
		}
		int x2 = table[i];//遍历到的数
		if (i == (x2 % divisor) || ((x2%divisor)> s)&&i> (x2 % divisor)) {
			continue;//当该数恰好在起始桶||删除的遍历到的数的起始桶在删除空位之后，且x2在起始桶之后
		}
		else {
			if ( i < s&& i>(x2 % divisor)) {
				continue;//遍历的位置在删除空位的前面，遍历的位置在删除数的起始桶前
			}
			if ((x2 % divisor) > s && s > i) {
				continue;//删除数的起始桶在删除的空位后，删除的空位在遍历的数前
			}
			int a = i;
			sum++;//除了以上的情况都要移动所以++
			while (table[(a + divisor-1) % divisor]!=-1  ) {
				a = (a + divisor - 1) % divisor;//从i开始向前遍历，直到有空位置
			}
			table[(a + divisor - 1) % divisor] = x2;//移动到该空位置
			table[i] = -1;//原位置改为空
			s = i;//将删除后空的位置改为此处
		}
	}
	cout << sum << endl;//循环结束输出统计的移动个数
}
int main() {
	int d, m;
	cin >> d >> m;
	hashTable h(d);
	for (int i = 0; i < m; i++) {
		int opt, x;
		cin >> opt >> x;
		if (opt == 0) {
			h.insert(x);
		}
		else if (opt == 1) {
			h.find(x);
		}
		else if (opt == 2) {
			h.deletes(x);
		}
	}
	return 0;
}

B : 链表散列

题目描述

要求

使用链表散列方式

描述

给定散列函数的除数 D 和操作数 m，输出每次操作后的状态。

有以下三种操作：

  1. 插入 x，若散列表已存在 x，输出"Existed"
  2. 查询 x，若散列表不含有 x，输出"Not Found"，否则输出 x 所在的链表长度
  3. 删除 x，若散列表不含有 x，输出"Delete Failed"，否则输出 x 所在链表删除 x 后的长度

输入输出格式

输入：

第一行两个整数D(1<=D<=3000)和m(1<=m<=3000)，其中D为散列函数的除数，m为操作数。

接下来的m行，每行两个整数opt和x，分别代表操作类型和操作数。

若opt为0，则代表向散列表中插入x；

若opt为1，代表查询散列表中x是否存在；

若opt为2，(如果散列表中含有x)，删除x。

输出：

按需输出。

数据结构与算法描述

构造一个节点结构体，和一个节点类，散列表类。将一个链表类chain* table作为散列表的私有成员，方便调用。

struct chainNode {//节点
	int element;
	chainNode* next;
};
class chain {//链表类
private:
	int listsize;//链表长度
	chainNode* firstNode;//首节点
public:
	chain() {
		listsize = 0;
		firstNode = NULL;
	}
	void insert(int val);
	int seek(int val);
	int erase(int val);
};
void chain::insert(int val) {//链表插入
	if (listsize == 0) {//插入的第一个数
		chainNode* newNode = new chainNode();
		newNode->element = val;
		newNode->next = firstNode;
		firstNode = newNode;
	}
	else {
		chainNode* p = firstNode;
		while (p->next != NULL) {//找到最后节点
			p = p->next;
		}
		chainNode* newNode = new chainNode();
		newNode->element = val;
		newNode->next = NULL;
		p->next = newNode;
	}
	listsize++;
}
int chain::seek(int val) {//链表查找
	chainNode* seekNode = firstNode;
	while (seekNode != NULL && seekNode->element != val) {
		seekNode = seekNode->next;
	}
	if (seekNode == NULL) {
		return -1;//找不到返回-1
	}
	else {
		return listsize;//找到返回链表长度
	}
}
int chain::erase(int val) {//链表删除
	if (firstNode->element == val) {//如果删除的是首节点
		chainNode* c = firstNode;
		firstNode = firstNode->next;
		delete c;
		listsize--;
		return listsize;//返回删除后的链表长度
	}
	chainNode* deleteNode = firstNode;
	while (deleteNode->next != NULL && deleteNode->next->element != val) {//找到删除节点的前一个节点
		deleteNode = deleteNode->next;
	}
	if (deleteNode->next == NULL) {
		return -1;//找不到返回-1
	}
	else {
		chainNode* p = deleteNode->next;//要删除的节点
		chainNode* q = p->next;//删除节点的下一个节点
		deleteNode->next = q;
		delete p;
		listsize--;
		return listsize;//返回删除后的链表藏毒
	}
}
class hashChain {//散列表类
private:
	chain* table;//链表
	int divisor;//除数
public:
	hashChain(int d) {
		divisor = d;
		table = new chain[divisor];
	}
	~hashChain() { delete[] table; }
	void dinsert(int x);
	void dfind(int x);
	void deletes(int x);
};

在散列表类的插入函数中先找到桶的位置为s然后调用table[s]链表的查找函数，如果不存在再调用table[s]链表的插入函数。

void hashChain::dinsert(int x) {//插入
	int s = x % divisor;
	if (table[s].seek(x) != -1) {//如果已经存在
		cout << "Existed" << endl;
		return;
	}
	else {
		table[s].insert(x);
	}
}

散列表类的查询函数，先找到桶的位置为s然后调用table[s]链表的查找函数，如果存在则输出链表查找函数的返回值。

void hashChain::dfind(int x) {//查询
	int s = x % divisor;
	if (table[s].seek(x) == -1) {//如果不存在
		cout << "Not Found" << endl;
	}
	else {
		cout << table[s].seek(x) << endl;
	}
}

在散列表类的删除函数中先找到桶的位置为s然后调用table[s]链表的查找函数，如果存在再调用table[s]链表的删除函数，并输出返回值。

void hashChain::deletes(int x) {//删除
	int s = x % divisor;
	if (table[s].seek(x) == -1) {//如果不存在
		cout << "Delete Failed" << endl;
	}
	else {
		cout << table[s].erase(x) << endl;
	}
}

测试结果

完整代码（含注释）

#include<iostream>
using namespace std;
struct chainNode {//节点
	int element;
	chainNode* next;
};
class chain {//链表类
private:
	int listsize;//链表长度
	chainNode* firstNode;//首节点
public:
	chain() {
		listsize = 0;
		firstNode = NULL;
	}
	void insert(int val);
	int seek(int val);
	int erase(int val);
};
void chain::insert(int val) {//链表插入
	if (listsize == 0) {//插入的第一个数
		chainNode* newNode = new chainNode();
		newNode->element = val;
		newNode->next = firstNode;
		firstNode = newNode;
	}
	else {
		chainNode* p = firstNode;
		while (p->next != NULL) {//找到最后节点
			p = p->next;
		}
		chainNode* newNode = new chainNode();
		newNode->element = val;
		newNode->next = NULL;
		p->next = newNode;
	}
	listsize++;
}
int chain::seek(int val) {//链表查找
	chainNode* seekNode = firstNode;
	while (seekNode != NULL && seekNode->element != val) {
		seekNode = seekNode->next;
	}
	if (seekNode == NULL) {
		return -1;//找不到返回-1
	}
	else {
		return listsize;//找到返回链表长度
	}
}
int chain::erase(int val) {//链表删除
	if (firstNode->element == val) {//如果删除的是首节点
		chainNode* c = firstNode;
		firstNode = firstNode->next;
		delete c;
		listsize--;
		return listsize;//返回删除后的链表长度
	}
	chainNode* deleteNode = firstNode;
	while (deleteNode->next != NULL && deleteNode->next->element != val) {//找到删除节点的前一个节点
		deleteNode = deleteNode->next;
	}
	if (deleteNode->next == NULL) {
		return -1;//找不到返回-1
	}
	else {
		chainNode* p = deleteNode->next;//要删除的节点
		chainNode* q = p->next;//删除节点的下一个节点
		deleteNode->next = q;
		delete p;
		listsize--;
		return listsize;//返回删除后的链表藏毒
	}
}
class hashChain {//散列表类
private:
	chain* table;//链表
	int divisor;//除数
public:
	hashChain(int d) {
		divisor = d;
		table = new chain[divisor];
	}
	~hashChain() { delete[] table; }
	void dinsert(int x);
	void dfind(int x);
	void deletes(int x);
};
void hashChain::dinsert(int x) {//插入
	int s = x % divisor;
	if (table[s].seek(x) != -1) {//如果已经存在
		cout << "Existed" << endl;
		return;
	}
	else {
		table[s].insert(x);
	}
}
void hashChain::dfind(int x) {//查询
	int s = x % divisor;
	if (table[s].seek(x) == -1) {//如果不存在
		cout << "Not Found" << endl;
	}
	else {
		cout << table[s].seek(x) << endl;
	}
}
void hashChain::deletes(int x) {//删除
	int s = x % divisor;
	if (table[s].seek(x) == -1) {//如果不存在
		cout << "Delete Failed" << endl;
	}
	else {
		cout << table[s].erase(x) << endl;
	}
}
int main() {
	int D, m;
	cin >> D >> m;
	hashChain h(D);
	for (int i = 0; i < m; i++) {
		int opt, x;
		cin >> opt >> x;
		if (opt == 0) {
			h.dinsert(x);
		}
		else if (opt == 1) {
			h.dfind(x);
		}
		else if (opt == 2) {
			h.deletes(x);
		}
	}
	return 0;
}

Star223333
关注
专栏目录
消息摘要（Message Digest）及其算法
oscar999的专栏
02-05 4373
java.security.Policy 抽象类 类加载器利用Policy对象决定代码在虚拟机中执行所拥有的权限。 一个应用程序对应一个策略对象， 一个策略对象对一个策略文件。 keystore “file://D:/inssoftware/tomcat7/webapps/applet/jdk6/cacerts”, “JKS”; keystore 密钥对存放的文件。 grant signedby...
第九章 集合
懒王子的专栏
12-02 8655
导读：　　一、 选择题　　1.若查找每个记录的概率均等，则在具有n个记录的连续顺序文件中采用顺序查找法查找一个记录，其平均查找长度ASL为( )。【北京航空航天大学2000 一、8 （2分）】 　　A． (n-1)/2 B. n/2 C. (n+1)/2 D. n　　2.对N个元素的表做顺序查找时，若查找
数据结构与算法（七）—— 散列表结构及其实现和应用
小羽毛的博客
01-06 2844
注：本篇内容参考了《Java常用算法手册》、《大话数据结构》和《Java编程（第四版）》三本书籍。 本人水平有限，文中如有错误或其它不妥之处，欢迎大家指正！ ...
山东大学软件学院数据结构复习题目
Sunnyztg的博客
12-17 906
数据结构期末复习题
山东大学软件学院数据结构练习题
Sunnyztg的博客
12-18 371
山东大学软件学院数据结构练习题
山大数据结构实验报告
qq_41022936的博客
10-17 1797
山东大学软件学院 《数据结构、算法与应用》实验指导书   一、实验要求 采用良好的编程风格；关键操作要有注释。 程序能够运行，显示运行结果。   二、 开发工具   Microsoft Visual C++ Eclipse IDE For C++   三、 实验题目 实验一 递归练习 一、实验目的 熟悉开发工具的使用。 掌握递归的实现思想。 二、实验内容 1、输出...
程序员的进阶课-架构师之路（16）-散列表（哈希表）
十步杀一人-千里不留行
08-18 858
前言 当我们在编程过程中，往往需要对线性表进行查找操作。在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。 但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键...
unit nine
热门推荐
mine_1的专栏
08-19 1万+
第九章  集合 一、 选择题 1.若查找每个记录的概率均等，则在具有n个记录的连续顺序文件中采用顺序查找法查找一个记录，其平均查找长度ASL为(    )。【北京航空航天大学 2000 一、8 （2分）】                       A． (n-1)/2
哈希表原理
wengmq的博客
03-21 504
什么是哈希？ 我们常常都能听到一些名词，哈希表、哈希函数、哈希冲突、哈希算法、一致性哈希，那么这些到底是什么鬼？ 首先我们要明白哈希的由来，为什么会有这个东西： 我们通常查找数据的方式有很多种，例如使用树，它们的查找都是先从根节点进行查找，从节点取出数据或索引与查找值进行比较，等等有很多方式，那么，有没有一种函数H，根据这个函数和查找关键字key，可以直接确定查找值所在位置，而不需要一个个比较。这...
【数据结构算法与应用-C++语言描述】中文版
11-24
本资源，"数据结构算法与应用-C++语言描述"，是山东大学指定的学习教材，现在有中文版供学习者使用，使得理解复杂的概念变得更加容易。 在数据结构方面，本书可能涵盖了以下几个核心主题： 1. **线性数据结构**：...
山东大学软件学院2018-2019 数据结构真题
01-10
3. 散列表的构建：Hash函数H(k)=k%7，散列表长为11，线性开型寻址法处理冲突，意味着如果哈希值相同，则在下一位置尝试存储。 4. 查找元素1，使用线性开型寻址法，查找次数取决于冲突次数，可能为1到11次。 5. ...
山东建筑大学数据结构复习资料.zip
01-14
本复习资料主要针对山东建筑大学的数据结构课程，旨在帮助学生理解和掌握数据结构的基本概念、原理和应用。 1. **基本概念**： - 数据：数据是信息的载体，是计算机处理的对象，可以是数字、文字、图像等。 - ...
2012-2013山大软件数据结构期末试题(真题)回顾
01-06
这份2012-2013年山大软件数据结构期末试题涉及到的主要知识点包括排序算法、散列表、树的遍历、二叉搜索树、图的搜索策略以及算法设计与分析。 一、排序算法： 1. 插入排序、选择排序、冒泡排序这三种都是基于比较...
2023年山东大学计算机学院数据结构真题.doc
10-27
数据结构是计算机科学中至关重要的一个领域，它研究如何有效地组织和存储数据，以便于高效...以上是对山东大学计算机学院数据结构真题的详细解析，涵盖了算法、数据结构的基本概念和应用，以及具体编程问题的解决策略。
数据结构：树的定义及其性质
pranaa的博客
09-24 708
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1187
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 582
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 778
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
散列表实现与应用：线性开型寻址与链表散列
实验内容涉及散列表的实现，包括线性开型寻址和链表散列两种方法，用于处理溢出问题。实验中需要设计一个字典，其关键字为整数，容量为961，插入500个不同的随机整数，并实现字典的建立、搜索和删除功能。实验环境为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值