1. 程式人生 > >雜湊表(二)(雜湊)開放定址法(平方)

雜湊表(二)(雜湊)開放定址法(平方)

編譯環境:vs2015

函式主體:


結構體:

程式碼:

// dataStructure-HashTable(2).cpp : Defines the entry point for the console application.
// hashTable-開放定址散列表

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define  ERROR  printf("error!") ;
typedef int ElementType;
struct HashEntry;
struct HashT;
typedef struct HashEntry Cell;
typedef struct HashT *HashTable;

//函式主體
//初始化
HashTable InitializeTable(int size);
//銷燬
void destory(HashTable Htable);
//查詢
int  findByKey(int key, HashTable Htable);
//插入
void insert(int key, HashTable Htable);
//刪除
void deleteT(int key, HashTable Htable);
//遍歷
void visited(HashTable Htable);
//返回位置
int Hash(int key, HashTable Htable);
//質數
int nextPrime(int size);

enum statusCode {
	Legitimate, Empty, Deleted
};

struct HashEntry
{
	ElementType element;
	enum statusCode status;
};
struct HashT
{
	int TableSize;
	Cell * TheCells;
};
int main()
{
	int size = 10;
	HashTable Htable = InitializeTable(size);
	for (int i = 0; i < size; i++)
	{
		insert(i*i, Htable);
	}
	deleteT(1,Htable);
	visited(Htable);
	destory(Htable);
	visited(Htable);
	return 0;
}

//初始化
HashTable InitializeTable(int size)
{

	HashTable Htable = (struct HashT *)malloc(sizeof(struct HashT));
	if (Htable == NULL) { printf("1"); ERROR; }
	Htable->TableSize = nextPrime(size);
	Htable->TheCells = (struct HashEntry*)malloc(Htable->TableSize * sizeof(struct HashEntry));
	if (Htable == NULL) { printf("2"); ERROR; }
	for (int i = 0; i < Htable->TableSize; i++)
	{
		Htable->TheCells[i].element = i;
		Htable->TheCells[i].status = Empty;
	}
	return Htable;
}
//銷燬
void destory(HashTable Htable)
{

	free(Htable->TheCells);
	Htable->TheCells = NULL;
	free(Htable);
	Htable = NULL;
}
//查詢
int  findByKey(int key, HashTable Htable)
{
	if (Htable == NULL) { printf("3"); ERROR; }
	int flag = Hash(key, Htable);
	int i = 0;
	while (Htable->TheCells[flag].status == Deleted || Htable->TheCells[flag].status == Legitimate)
	{
		//走到下一個格子
		//f(x)=x^2 , f(x-1)=(x-1)^2  f(x)-f(x-1)=2*x-1;
		flag = flag + 2 * (++i) - 1;
		printf("%d\n",flag);
		//超出表格,重頭來
		if (flag >= Htable->TableSize)
		{
			flag = flag - Htable->TableSize;
		}
	}
	return flag;
}
//插入
void insert(int key, HashTable Htable)
{
	if (Htable == NULL) { printf("4"); ERROR; }
	Cell * cell = &(Htable->TheCells[findByKey(key, Htable)]);
	cell->element = key;
	cell->status = Legitimate;
}
//刪除
void deleteT(int key, HashTable Htable)
{
	if (Htable == NULL) { printf("5"); ERROR; }
	Cell * cell = &(Htable->TheCells[findByKey(key, Htable)]);
	cell->status = Deleted;
}
//遍歷
void visited(HashTable Htable)
{
	if (Htable == NULL) { printf("6"); ERROR; }
	for (int i = 0; i < Htable->TableSize; i++)
	{
		//if (Htable->TheCells[i].status == 0)
		{
			printf("%d\t%d\n", Htable->TheCells[i].element, Htable->TheCells[i].status);
		}
		
	}
}

int Hash(int key, HashTable Htable)
{
	if (Htable == NULL) { printf("7"); ERROR; }
	int newKey = key%Htable->TableSize;
	return newKey;
}


//接近的下一個質數
int nextPrime(int x)
{
	int flag = 0;
	for (int i = 2 * x; flag == 0; i++)
	{
		int j = 2;
		for (; j <= sqrt(i); j++)
		{
			if (i%j == 0)
			{
				break;
			}
		}
		if (j == (int)sqrt(i) + 1)
		{
			flag = i;
		}
	}
	return flag;
}


相關推薦

()()開放平方

編譯環境:vs2015 函式主體: 結構體: 程式碼: // dataStructure-HashTable(2).cpp : Defines the entry point for the console application. // hashTable-開放定址

——開放

一、Hash.h #ifndef __HASH_H__ #define __HASH_H__ #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int HashDa

演算法導論 第十一章:散列表 筆記直接、散列表、通過連結解決碰撞、函式、開放、完全

前面討論的各種資料結構中,記錄在各種結構中的相對位置是隨機的,和在記錄的關鍵字之間不存在有確定的關係,因此在查詢記錄是需要進行一系列和關鍵字的比較。而理想的情況是不希望進行任何的比較,一次存取便能得到所查記錄。那就必須在記錄的儲存位置和它的關鍵字之間建立一種確定的關係f,使每個關鍵字和結構中有一

HashTable——開放

1 基本知識 Hash Table-散列表/雜湊表,是根據關鍵字(key)而直接訪問在記憶體儲存位置的資料結構。它通過一個關鍵值的函式將所需的資料對映到表中的位置來訪問資料,這個對映函式叫做雜湊函式,存放記錄的陣列叫做散列表。 1.1 構造雜湊表的方法 1

C++資料結構--.線性探測開放與獨立錶鏈地址

class hashTable {friend class hashIterator;private:vector<list<T>> table; hashFun fun;  //雜湊函式物件size_t rows;    public:#include"hashIterator.h"

java 解決Hash()衝突的四種方法--開放(線性探測,次探測,偽隨機探測)、鏈地址、再、建立公共溢位區

一)雜湊表簡介 非雜湊表的特點:關鍵字在表中的位置和它之間不存在一個確定的關係,查詢的過程為給定值一次和各個關鍵字進行比較,查詢的效率取決於和給定值進行比較的次數。     雜湊表的特點:關鍵字在表中位置和它之間存在一種確定的關係。 雜湊函式:一般情況下,需要在

(HashTable)的開放和鏈地址的實現

 散列表(Hash table,也叫雜湊表),是根據關鍵碼值(Key value)而直接進行訪問的資料結構。也就是說,它通過把關鍵碼值對映到表中一個位置來訪問記錄,以加快查詢的速度。這個對映函式叫做雜湊函式,存放記錄的陣列叫做散列表。引用(百度) 演算法時間複雜度分析

[資料結構]Hash初學開放

/* Name:Hash表初學 (陣列實現連結串列 開放定址法 ) Actor:HT Time:2015年9月29日 Error Reporte: */ #include"stdio.h"

C語言 開放HASH儲存簡單實現

#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> #include<time.h> #include<cty

數據結構之散列開放

測試用例 開放定址法 測試 可能 print 信息 stat gif try 1 // OHash 2 // 關鍵字:int 3 // Hash函數:hash(X) = X mod TableSize 4 // 沖突解決方法:開放定址法。Index(X, i) =

《激盪三十年》、改革開放前的中國

上一期我們說了上海試驗取得成功之後,在中國第一次五年計劃結束的1957年前後,黨人幾乎同時取得了經濟高速成長和清除民營經濟兩個重大的勝利。社會主義計劃經濟現在看上去如同天使的饋贈,但是沒想到它卻是魔鬼的詛咒。這使得治國者的信心前所未有的膨脹。隨後,中國巨龍在自負的道路上越走越遠。 1

鏈地址開放,求等概率下查詢成功時的平均查詢長度

問題描述: 演算法與資料結構的一個題目,用鏈地址法和開放定址法,求等概率情況下查詢成功時的平均查詢長度 已知一組關鍵字(13,20,85,52,8),雜湊函式為:H(key)=key MOD 6

散列表的開放

開放定址法(open addressing)中,所有元素都存放在槽中,在連結串列法散列表中,每個槽中儲存的是相應連結串列的指標,為了維護一個連結串列,連結串列的每個結點必須有一個額外的域來儲存它的前戲和後繼結點。開放定址法不在槽外儲存元素,不使用指標,也不必須為了維護一個

演算法導論11.4開放 練習總結

11.4-1 考慮將關鍵字 10、22、31、4、15、28、17、88、59用開放定址法插入到一個長度為 m = 11 的散列表中,輔助雜湊函式為 h'( k ) = k mod m。試說明分別用線性探查,二次探查(c1 = 1,c2 = 3) 和雙重雜湊h2( k )

CLRS 11.4開放

11.4-1 只給出結果,如下: 11.4-2 HASH-DELETE(T,k) i=0 repeat j = h(k,i) if ( T[

[資料結構]散列表-連結開放 線性探查

在介紹hash表之前首先提到直接定址表 但是由於實際上儲存在字典裡的關鍵字集合K比實際上所有可能的關鍵字的全域U要小的多,因此散列表所需要的儲存空間比直接定址表要小的多  通過雜湊函式 h:U -> {0,1,2…m-1} 其中m 遠小於|U| 但是對於h

開放(線性探測),拉鍊 -Hash演算法

總結: 雜湊別名為:Hash 或者 散列表; 開放定址法是為了解決hash值碰撞後的處理; 散列表(雜湊)是演算法在時間和空間上作出權衡的經典例子。 如果沒有記憶體限制,我們可以直接將鍵作為(可能是一個超大的)陣列的索引,那麼所有查詢操作只需

寫給自己看的散列表(2):開放

delete print log null i++ == must 定義 刪除 搬運自我的CSDN https://blog.csdn.net/u013213111/article/details/88870924 1.定義 在開放定址法中,用一個數組來存儲散列表的元素

散列表(線性探測、次探測)解決衝突、負載因子

雜湊概念 常規搜尋:   資料雜亂無章——->順序查詢—–>時間複雜度0(n)。   資料有序—–>二分查詢——>時間複雜度0(log(n))。   建立二叉搜尋樹—–>時間複雜度0(n)(單支樹)。 理想的搜尋方法是:可

最小堆//叉樹/平衡叉樹/紅黑樹的意義

接觸堆資料結構是在排序裡面講的,空間複雜度O(1),時間複雜度O(NlogN),但是在實踐中還是不如快速排序(好像快速排序可以更好的利用硬體特性)。堆 的意義就在於:最快的找到最大/最小值,在堆結構中插入一個值重新構造堆結構,取走最大/最下值後重新構造堆結構 其時間複雜度為O(logN),而其他方法最少為O