散列 - C语言实现（摘自数据结构与算法分析 C语言描述）

最新推荐文章于 2023-03-22 10:23:27 发布
最新推荐文章于 2023-03-22 10:23:27 发布
阅读量669 收藏 1
点赞数
分类专栏： 嵌入式 文章标签： 算法

一、概述

　　散列表（hash table）ADT只支持二叉查找树所允许的一部分操作，散列表的实现常常叫做散列（hashing）。散列是一种以常数平均时间执行插入、删除和查找的技术。但是，那些需要元素间任何排序信息的操作将不会得到有效的支持。

二、实现

　　理想的散列表数据结构只不过是一个包含有关关键字的具有固定大小的数组。典型情况下，一个关键字就是一个带有相关值的字符串。我们把表的大小记作TableSize，并将其理解为散列数据结构的一部分而不仅仅是浮动于全局的某个变量。通常的习惯是让表从０到TableSize - 1变化。每个关键字被映射到从０到TableSize - 1这个范围中的某个数，并且被放到适当的单元中。这个映射就叫做散列函数（hash function），理想情况下它应该运算简单并且应该保证任何两个不同的关键字映射到不同的单元。不过，这是不可能的，因为单元的数目是有限的，而关键字实际上是用不完的。因此，我们寻找一个散列函数，该函数要在单元之间均匀地分配关键字。

　　这就是散列的基本想法。剩下的问题则是要选择一个函数，决定当两个关键字散列到同一个值的时候（称为冲突（collision））应该做什么以及如何确定散列表的大小。

如果输入的关键字是整数，则一般合理的方法就是直接返回“Key mod Tablesize”的结果，除非Key碰巧具有某些不理想的性质。在这种情况下，散列函数的选择需要仔细考虑。

　　解决冲突的方法有几种，我们将讨论其中最简单的两种：分离链接法和开放定址法。

１. 分离链接法

　　其做法是将散列到同一个值的所有元素保留到一个表中，为方便起见，这些表都有表头（表的大小不是素数，用在这里是为了简单），如图１所示。


图１　分离链接散列表

文件名：hashsep.h

[cpp] view plain copy print ?
  1. #ifndef _HashSep_H   
  2.   
  3. typedef int ElementType;  
  4.   
  5. typedef unsigned int Index;  
  6.   
  7. struct ListNode;  
  8. typedef struct ListNode *Position;  
  9. struct HashTbl;  
  10. typedef struct HashTbl *HashTable;  
  11.   
  12. Index Hash( const int Key, int TableSize );  
  13.   
  14. HashTable InitializeTable( int TableSize );  
  15. void DestroyTable( HashTable H );  
  16. Position Find( ElementType Key, HashTable H );  
  17. void Insert( ElementType Key, HashTable H );  
  18. ElementType Retrieve( Position P );  
  19. /* Routines such as Delete and MakeEmpty are omitted */  
  20.   
  21.   
  22. #endif /* _HashSep_H */  
#ifndef _HashSep_H

typedef int ElementType;

typedef unsigned int Index;

struct ListNode;
typedef struct ListNode *Position;
struct HashTbl;
typedef struct HashTbl *HashTable;

Index Hash( const int Key, int TableSize );

HashTable InitializeTable( int TableSize );
void DestroyTable( HashTable H );
Position Find( ElementType Key, HashTable H );
void Insert( ElementType Key, HashTable H );
ElementType Retrieve( Position P );
/* Routines such as Delete and MakeEmpty are omitted */


#endif /* _HashSep_H */

文件名：hashsep.c

[cpp] view plain copy print ?
  1. #include "fatal.h"   
  2. #include "hashsep.h"   
  3. #define MinTableSize (10)   
  4. typedef Position List;  
  5.   
  6. Index Hash( const int Key, int TableSize )  
  7. {  
  8.     return Key % TableSize;  
  9. }  
  10.   
  11. struct ListNode  
  12. {  
  13.     ElementType Element;  
  14.     Position Next;  
  15. };  
  16.   
  17. /* List *TheList will be an array of lists,allocated later */  
  18. /* The lists use headers (for simplicity), */  
  19. /* though this wastes space */  
  20. struct HashTbl  
  21. {  
  22.     int TableSize;  
  23.     List *TheLists;  
  24. };  
  25.   
  26. /* Return next prime; assume N >= 10 */  
  27. static int  
  28. NextPrime( int N )  
  29. {  
  30.     int i;  
  31.   
  32.     if( N % 2 == 0 )  
  33.         N++;  
  34.     for( ; ; N += 2 )  
  35.     {  
  36.         for( i = 3; i * i <= N; i += 2 )  
  37.             if( N % i == 0 )  
  38.                 goto ContOuter;  /* Sorry about this! */  
  39.         return N;  
  40. ContOuter: ;  
  41.     }  
  42. }  
  43.   
  44. HashTable  
  45. InitializeTable( int TableSize )  
  46. {  
  47.     HashTable H;  
  48.     int i;  
  49.   
  50.     if ( TableSize < MinTableSize )  
  51.     {  
  52.         Error( "Table size too small" );  
  53.         return NULL;  
  54.     }  
  55.   
  56.     /* Allocate table */  
  57.     H = malloc( sizeof( struct HashTbl ) );  
  58.     if ( H == NULL)  
  59.         FatalError( "Out of space!!!" );  
  60.   
  61.     H->TableSize = NextPrime( TableSize );  
  62.   
  63.     /* Allocate array of lists */  
  64.     H->TheLists = malloc( sizeof( List ) * H->TableSize );  
  65.     if( H->TheLists == NULL )  
  66.         FatalError( "Out of space!!!" );  
  67.   
  68.     /* Allocate list headers */  
  69.     for( i = 0; i < H->TableSize; i++ )  
  70.     {  
  71.         H->TheLists[ i ] = malloc( sizeof( struct ListNode ) );  
  72.         if ( H->TheLists[ i ] == NULL )  
  73.             FatalError( "Out of space!!!" );  
  74.         else  
  75.             H->TheLists[ i ]->Next = NULL;  
  76.     }  
  77.       
  78.     return H;  
  79. }  
  80.   
  81. Position   
  82. Find( ElementType Key, HashTable H )  
  83. {  
  84.     Position P;  
  85.     List L;  
  86.   
  87.     L = H->TheLists[ Hash( Key, H->TableSize )];  
  88.     P = L->Next;  
  89.   
  90.     while( P != NULL && P->Element != Key )  
  91.         /* Probably need strcmp!! */  
  92.         P = P->Next;  
  93.       
  94.     return P;  
  95. }  
  96.   
  97. void  
  98. Insert( ElementType Key, HashTable H )  
  99. {  
  100.     Position Pos, NewCell;  
  101.     List L;  
  102.       
  103.     Pos = Find( Key, H );  
  104.     if ( Pos == NULL ) /* Key is not found */  
  105.     {  
  106.         NewCell = malloc( sizeof( struct ListNode ) );  
  107.         if ( NewCell == NULL )  
  108.             FatalError( "Out of space!!!" );  
  109.         else  
  110.         {  
  111.             L = H->TheLists[ Hash( Key, H->TableSize ) ];  
  112.             NewCell->Next = L->Next;  
  113.             NewCell->Element = Key; /* Probably need strcpy!! */  
  114.             L->Next = NewCell;  
  115.         }  
  116.     }  
  117. }  
  118. void  
  119. DestroyTable( HashTable H )  
  120. {  
  121.     int i;  
  122.   
  123.     for( i = 0; i < H->TableSize; i++ )  
  124.     {  
  125.         Position P = H->TheLists[ i ];  
  126.         Position Tmp;  
  127.   
  128.         while( P != NULL )  
  129.         {  
  130.             Tmp = P->Next;  
  131.             free( P );  
  132.             P = Tmp;  
  133.         }  
  134.     }  
  135.   
  136.     free( H->TheLists );  
  137.     free( H );  
  138. }  
  139.   
  140.   
  141. ElementType Retrieve( Position P )  
  142. {  
  143.     return P->Element;  
  144. }  
#include "fatal.h"
#include "hashsep.h"
#define MinTableSize (10)
typedef Position List;

Index Hash( const int Key, int TableSize )
{
	return Key % TableSize;
}

struct ListNode
{
	ElementType Element;
	Position Next;
};

/* List *TheList will be an array of lists,allocated later */
/* The lists use headers (for simplicity), */
/* though this wastes space */
struct HashTbl
{
	int TableSize;
	List *TheLists;
};

/* Return next prime; assume N >= 10 */
static int
NextPrime( int N )
{
	int i;

	if( N % 2 == 0 )
		N++;
	for( ; ; N += 2 )
	{
		for( i = 3; i * i <= N; i += 2 )
			if( N % i == 0 )
				goto ContOuter;  /* Sorry about this! */
		return N;
ContOuter: ;
	}
}

HashTable
InitializeTable( int TableSize )
{
	HashTable H;
	int i;

	if ( TableSize < MinTableSize )
	{
		Error( "Table size too small" );
		return NULL;
	}

	/* Allocate table */
	H = malloc( sizeof( struct HashTbl ) );
	if ( H == NULL)
		FatalError( "Out of space!!!" );

	H->TableSize = NextPrime( TableSize );

	/* Allocate array of lists */
	H->TheLists = malloc( sizeof( List ) * H->TableSize );
	if( H->TheLists == NULL )
		FatalError( "Out of space!!!" );

	/* Allocate list headers */
	for( i = 0; i < H->TableSize; i++ )
	{
		H->TheLists[ i ] = malloc( sizeof( struct ListNode ) );
		if ( H->TheLists[ i ] == NULL )
			FatalError( "Out of space!!!" );
		else
			H->TheLists[ i ]->Next = NULL;
	}
	
	return H;
}

Position 
Find( ElementType Key, HashTable H )
{
	Position P;
	List L;

	L = H->TheLists[ Hash( Key, H->TableSize )];
	P = L->Next;

	while( P != NULL && P->Element != Key )
		/* Probably need strcmp!! */
		P = P->Next;
	
	return P;
}

void
Insert( ElementType Key, HashTable H )
{
	Position Pos, NewCell;
	List L;
	
	Pos = Find( Key, H );
	if ( Pos == NULL ) /* Key is not found */
	{
		NewCell = malloc( sizeof( struct ListNode ) );
		if ( NewCell == NULL )
			FatalError( "Out of space!!!" );
		else
		{
			L = H->TheLists[ Hash( Key, H->TableSize ) ];
			NewCell->Next = L->Next;
			NewCell->Element = Key; /* Probably need strcpy!! */
			L->Next = NewCell;
		}
	}
}
void
DestroyTable( HashTable H )
{
	int i;

	for( i = 0; i < H->TableSize; i++ )
	{
		Position P = H->TheLists[ i ];
		Position Tmp;

		while( P != NULL )
		{
			Tmp = P->Next;
			free( P );
			P = Tmp;
		}
	}

	free( H->TheLists );
	free( H );
}


ElementType Retrieve( Position P )
{
	return P->Element;
}

文件名：main.c

[cpp] view plain copy print ?
  1. #include "hashsep.h"   
  2. #include <stdio.h>   
  3.   
  4. int main()  
  5. {  
  6.     HashTable H = InitializeTable( 10 );  
  7.     int i;  
  8.     printf( "HashTable:\n" );  
  9.     for ( i = 1; i < 11; i++ )  
  10.     {  
  11.         Insert( i * i, H );  
  12.         printf( "%d:%d\n", i*i, Hash( i * i, 10 ) );  
  13.     }  
  14.     return 0;  
  15. }  
#include "hashsep.h"
#include <stdio.h>

int main()
{
	HashTable H = InitializeTable( 10 );
	int i;
	printf( "HashTable:\n" );
	for ( i = 1; i < 11; i++ )
	{
		Insert( i * i, H );
		printf( "%d:%d\n", i*i, Hash( i * i, 10 ) );
	}
	return 0;
}



２. 开放定址法

分离链接散列算法的缺点是需要指针，由于给新单元分配地址需要时间，因此就导致算法的速度多少有些减慢，同时算法实际上还要求对另一种数据结构的实现。除使用链表解决冲突外，开放定址散列法（Open addressing hashing）是另外一种不用链表解决冲突的方法。在开放定址散列算法系统中，如果有冲突发生，那么就要尝试选择另外的单元，直到找出空的单元为止。

文件名：hashquad.h

[cpp] view plain copy print ?
  1. #ifndef _HashQuad_H   
  2.   
  3. typedef int ElementType;  
  4.   
  5. typedef unsigned int Index;  
  6. typedef Index Position;  
  7.   
  8. struct HashTbl;  
  9. typedef struct HashTbl *HashTable;  
  10.   
  11. static int NextPrime( int N );  
  12. Index Hash( ElementType Key, int TableSize );  
  13. HashTable InitializeTable( int TableSize );  
  14. void DestroyTable( HashTable H );  
  15. Position Find( ElementType Key, HashTable H );  
  16. void Insert( ElementType Key, HashTable H );  
  17. ElementType Retrieve( Position P, HashTable H );  
  18. HashTable Rehash( HashTable H );  
  19. /* Routines such as Delete and MakeEmpty are omitted */  
  20. #endif /* _HashQuad_H */  
#ifndef _HashQuad_H

typedef int ElementType;

typedef unsigned int Index;
typedef Index Position;

struct HashTbl;
typedef struct HashTbl *HashTable;

static int NextPrime( int N );
Index Hash( ElementType Key, int TableSize );
HashTable InitializeTable( int TableSize );
void DestroyTable( HashTable H );
Position Find( ElementType Key, HashTable H );
void Insert( ElementType Key, HashTable H );
ElementType Retrieve( Position P, HashTable H );
HashTable Rehash( HashTable H );
/* Routines such as Delete and MakeEmpty are omitted */
#endif /* _HashQuad_H */

文件名：hashquad.c

[cpp] view plain copy print ?
  1. #include "hashquad.h"   
  2. #include "fatal.h"   
  3.   
  4. #define MinTableSize (10)   
  5.   
  6. enum KindOfEntry { Legitimate, Empty, Deleted };  
  7.   
  8. struct HashEntry  
  9. {  
  10.     ElementType Element;  
  11.     enum KindOfEntry Info;  
  12. };  
  13.   
  14. typedef struct HashEntry Cell;  
  15.   
  16. /* Cell *TheCells will be an array of */  
  17. /* HashEntry cells, allocated later */  
  18. struct HashTbl  
  19. {  
  20.     int TableSize;  
  21.     Cell *TheCells;  
  22. };  
  23.   
  24. /* Return next prime; assume N >= 10 */  
  25.   
  26. static int  
  27. NextPrime( int N )  
  28. {  
  29.     int i;  
  30.   
  31.     if( N % 2 == 0 )  
  32.         N++;  
  33.     for( ; ; N += 2 )  
  34.     {  
  35.         for( i = 3; i * i <= N; i += 2 )  
  36.             if( N % i == 0 )  
  37.                 goto ContOuter;  /* Sorry about this! */  
  38.         return N;  
  39. ContOuter: ;  
  40.     }  
  41. }  
  42.   
  43. /* Hash function for ints */  
  44. Index  
  45. Hash( ElementType Key, int TableSize )  
  46. {  
  47.     return Key % TableSize;  
  48. }  
  49.   
  50. HashTable  
  51. InitializeTable( int TableSize )  
  52. {  
  53.     HashTable H;  
  54.     int i;  
  55.   
  56.     if ( TableSize < MinTableSize )  
  57.     {  
  58.         Error( "Table size too small!" );  
  59.         return NULL;  
  60.     }  
  61.   
  62.     /* Allocate table */  
  63.     H = malloc( sizeof( struct HashTbl ) );  
  64.     if ( H == NULL )  
  65.         FatalError( "Out of space!!!" );  
  66.   
  67.     H->TableSize = NextPrime( TableSize );  
  68.   
  69.     /* Allocate array of Cells */  
  70.     H->TheCells = malloc( sizeof( Cell ) * H->TableSize );  
  71.     if ( H->TheCells == NULL )  
  72.         FatalError( "Out of space!!!" );  
  73.   
  74.     for ( i = 0; i < H->TableSize; i++ )  
  75.         H->TheCells[ i ].Info = Empty;  
  76.       
  77.     return H;  
  78. }  
  79.   
  80. Position  
  81. Find( ElementType Key, HashTable H )  
  82. {  
  83.     Position CurrentPos;  
  84.     int CollisionNum;  
  85.   
  86.     CollisionNum = 0;  
  87.     CurrentPos = Hash( Key, H->TableSize );  
  88.     while ( H->TheCells[ CurrentPos ].Info != Empty &&  
  89.         H->TheCells[ CurrentPos ].Element != Key )  
  90.         /* Probably need strcpy! */  
  91.     {  
  92.         CurrentPos += 2 * ++CollisionNum - 1;  
  93.         if ( CurrentPos >= H->TableSize )  
  94.             CurrentPos -= H->TableSize;  
  95.     }  
  96.     return CurrentPos;  
  97. }  
  98.   
  99. void  
  100. Insert( ElementType Key, HashTable H )  
  101. {  
  102.     Position Pos;  
  103.   
  104.     Pos = Find( Key, H );  
  105.     if ( H->TheCells[ Pos ].Info != Legitimate )  
  106.     {  
  107.         /* Ok to insert here */  
  108.         H->TheCells[ Pos ].Info = Legitimate;  
  109.         H->TheCells[ Pos ].Element = Key; /* Probably need strcpy! */  
  110.     }  
  111. }  
  112.   
  113. HashTable  
  114. Rehash( HashTable H )  
  115. {  
  116.     int i, OldSize;  
  117.     Cell *OldCells;  
  118.   
  119.     OldCells = H->TheCells;  
  120.     OldSize = H->TableSize;  
  121.   
  122.     /* Get a new, empty table */  
  123.     H = InitializeTable( 2 * OldSize );  
  124.       
  125.     /* Scan through old table, reinserting into new */  
  126.     for( i = 0; i < OldSize; i++ )  
  127.         if ( OldCells[ i ].Info == Legitimate )  
  128.             Insert( OldCells[ i ].Element, H );  
  129.   
  130.     free( OldCells );  
  131.   
  132.     return H;  
  133. }  
  134.   
  135. ElementType  
  136. Retrieve( Position P, HashTable H )  
  137. {  
  138.     return H->TheCells[ P ].Element;  
  139. }  
  140.   
  141. void  
  142. DestroyTable( HashTable H )  
  143. {  
  144.     free( H->TheCells );  
  145.     free( H );  
  146. }  
#include "hashquad.h"
#include "fatal.h"

#define MinTableSize (10)

enum KindOfEntry { Legitimate, Empty, Deleted };

struct HashEntry
{
	ElementType Element;
	enum KindOfEntry Info;
};

typedef struct HashEntry Cell;

/* Cell *TheCells will be an array of */
/* HashEntry cells, allocated later */
struct HashTbl
{
	int TableSize;
	Cell *TheCells;
};

/* Return next prime; assume N >= 10 */

static int
NextPrime( int N )
{
	int i;

	if( N % 2 == 0 )
		N++;
	for( ; ; N += 2 )
	{
		for( i = 3; i * i <= N; i += 2 )
			if( N % i == 0 )
				goto ContOuter;  /* Sorry about this! */
		return N;
ContOuter: ;
	}
}

/* Hash function for ints */
Index
Hash( ElementType Key, int TableSize )
{
	return Key % TableSize;
}

HashTable
InitializeTable( int TableSize )
{
	HashTable H;
	int i;

	if ( TableSize < MinTableSize )
	{
		Error( "Table size too small!" );
		return NULL;
	}

	/* Allocate table */
	H = malloc( sizeof( struct HashTbl ) );
	if ( H == NULL )
		FatalError( "Out of space!!!" );

	H->TableSize = NextPrime( TableSize );

	/* Allocate array of Cells */
	H->TheCells = malloc( sizeof( Cell ) * H->TableSize );
	if ( H->TheCells == NULL )
		FatalError( "Out of space!!!" );

	for ( i = 0; i < H->TableSize; i++ )
		H->TheCells[ i ].Info = Empty;
	
	return H;
}

Position
Find( ElementType Key, HashTable H )
{
	Position CurrentPos;
	int CollisionNum;

	CollisionNum = 0;
	CurrentPos = Hash( Key, H->TableSize );
	while ( H->TheCells[ CurrentPos ].Info != Empty &&
		H->TheCells[ CurrentPos ].Element != Key )
		/* Probably need strcpy! */
	{
		CurrentPos += 2 * ++CollisionNum - 1;
		if ( CurrentPos >= H->TableSize )
			CurrentPos -= H->TableSize;
	}
	return CurrentPos;
}

void
Insert( ElementType Key, HashTable H )
{
	Position Pos;

	Pos = Find( Key, H );
	if ( H->TheCells[ Pos ].Info != Legitimate )
	{
		/* Ok to insert here */
		H->TheCells[ Pos ].Info = Legitimate;
		H->TheCells[ Pos ].Element = Key; /* Probably need strcpy! */
	}
}

HashTable
Rehash( HashTable H )
{
	int i, OldSize;
	Cell *OldCells;

	OldCells = H->TheCells;
	OldSize = H->TableSize;

	/* Get a new, empty table */
	H = InitializeTable( 2 * OldSize );
	
	/* Scan through old table, reinserting into new */
	for( i = 0; i < OldSize; i++ )
		if ( OldCells[ i ].Info == Legitimate )
			Insert( OldCells[ i ].Element, H );

	free( OldCells );

	return H;
}

ElementType
Retrieve( Position P, HashTable H )
{
	return H->TheCells[ P ].Element;
}

void
DestroyTable( HashTable H )
{
	free( H->TheCells );
	free( H );
}

文件名：main.c

[cpp] view plain copy print ?
  1. #include "hashquad.h"   
  2. #include <stdio.h>   
  3.   
  4. int main()  
  5. {  
  6.     HashTable H = InitializeTable( 10 );  
  7.     int i;  
  8.     printf( "Hash Table: \n" );  
  9.     for ( i = 1; i < 11; i++ )  
  10.     {  
  11.         Insert( i * i, H );  
  12.         printf( "%d:%d\n", i*i, Hash( i * i, 10 ) );  
  13.     }  
  14.     return 0;  
  15. }  
#include "hashquad.h"
#include <stdio.h>

int main()
{
	HashTable H = InitializeTable( 10 );
	int i;
	printf( "Hash Table: \n" );
	for ( i = 1; i < 11; i++ )
	{
		Insert( i * i, H );
		printf( "%d:%d\n", i*i, Hash( i * i, 10 ) );
	}
	return 0;
}



附录：上述代码中用到了Error、FatalError等函数，其实现如下（即fatal.h文件）：
[cpp] view plain copy print ?
  1. #include <stdio.h>   
  2. #include <stdlib.h>   
  3.   
  4. #define Error( Str )        FatalError( Str )   
  5. #define FatalError( Str )   fprintf( stderr, "%s\n", Str ), exit( 1 )  
#include <stdio.h>
#include <stdlib.h>

#define Error( Str )        FatalError( Str )
#define FatalError( Str )   fprintf( stderr, "%s\n", Str ), exit( 1 )

备注：本文摘自《数据结构与算法分析 C语言描述 Mark Allen Weiss著》，代码经gcc编译测试通过。

附件下载：http://download.csdn.net/detail/shuxiao9058/4212416#hashsep_20120406.tar.gz ，http://download.csdn.net/detail/shuxiao9058/4212417# hashquad_20120406.tar.gz

Vampaire27
关注
专栏目录
数据结构（一） -- C语言版 -- 基本概念与算法基本概念
青椒*^_^*凤爪爪的博客
03-10 5776
主要是研究非数值性程序设计中计算机操作的对象（数据）及其相互间关系和运算的学科。也可以简单理解为研究数据对象中数据元素之间的关系（数组、链表、树、图）。 算法（Algorithm）是一个有穷规则（或语句、指令）的有序集合。它确定了解决某一问题的一个运算序列。对于问题的初始输入，通过算法有限步的运行，产生一个或多个输出。
【安全算法之概述】一文带你简要了解常见常用的安全算法（RT-Thread技术论坛优秀文章）
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
10-20 1万+
【安全算法】一文带你简要了解常见常用的安全算法**0 前言****1 算法的大致分类****2 对称加解密算法****2.1 DES/TDES算法****2.2 AES算法****2.3 SM4算法****2.4 RC2、RC4算法****2.5 对称加密算法对比总结****3 非对称加解密算法****3.1 对称加密算法与非对称加密算法的本质区别****3.2 非对称加密算法的分类和对比****3.2.1 RSA算法****3.2.2 SM2算法****3.2.3 ECC算法**3.2.3.1 **优点*
C语言之散列
znufe_newer的博客
03-26 1284
c语言hash相关应用
散列函数c语言实现,哈希表的C语言实现
weixin_29009501的博客
05-20 327
#include #include#include#define BUCKETCOUNT 16structhashEntry{const char*key;char*value;struct hashEntry*next;};typedefstructhashEntry entry;structhashTable{entry bucket[BUCKETCOUNT];//先默认定义16个桶};typ...
散列/哈希查找 C语言实现
热门推荐
WTF
12-16 1万+
1、基本概念 散列(hash)同顺序、链接和索引一样，是存储数据的又一种方法。 散列存储的基本思想是：以数据（通常为集合）中的每个元素的关键字K为自变量，通过一种函数h(K)计算出函数值， 把这个值解释为一块连续存储空间(即数组空间或文件空间)的单元地址(即下标)，将该元素存储到这个单元中。 散列存储中使用的函数h(K)，称为散列函数或哈希函数，它实现关键字到存储地址的映射(或称转
《数据结构-C语言实现散列表(Hash)》
最新发布
Like_Bamboo的博客
03-22 1943
注意，在本例中，我们假设键是字符串，但是在实际应用中，键可以是任何类型，只要可以计算散列值并进行比较即可。函数用于计算散列值，采用了一个简单的散列算法，即将每个字符的ASCII码乘以一个质数31，并将结果相加。函数用于向散列表中插入一个元素，计算键的散列值并将元素指针存储在相应的散列表位置中。在主函数中，我们首先创建一个新的散列表，然后向散列表中插入三个元素。函数用于在散列表中查找一个元素，根据键的散列值定位元素并比较键的值是否相等。结构体，表示散列表中的元素，包含一个键和一个值。2.冲突解决方法的实现。
深入浅出数据结构C语言版（14）——散列表
词语大杂烩
09-04 403
我们知道，由于二叉树的特性（完美情况下每次比较可以排除一半数据），对其进行查找算是比较快的了，时间复杂度为O(logN)。但是，是否存在支持时间复杂度为常数级别的查找的数据结构呢？答案是存在，那就是散列表（hash table，又叫哈希表）。散列表可以支持O(1)的插入，理想情况下可以支持O(1)的查找与删除。   　　散列表的基本思想很简单： 　　1.设计一个散列函数，其输入为
哈希加密c语言算法,[原创]逆向中常见的Hash算法和对称加密算法的分析
weixin_33728584的博客
05-24 1181
逆向中常常出现一些加密算法，如果我们能对这些加密算法进行快速识别则会大大减少我们逆向的难度，虽然IDA已有密码分析神器Findcrypt，但掌握手动分析方法能帮助我们应对更多的情况。这篇文章将介绍逆向中常见的单项散列算法和对称加密算法的识别方法。0xFF. 前言在很长一段时间里我经常发现自己面对复杂的加密算法无从下手，可能是因为还没有系统学过密码学吧orz，总之这个问题困扰了我很久。于是最近我花了...
逆向中常见的Hash算法和对称加密算法的分析
Test网络安全
09-07 8567
逆向中常常出现一些加密算法，如果我们能对这些加密算法进行快速识别则会大大减少我们逆向的难度，虽然IDA已有密码分析神器Findcrypt，但掌握手动分析方法能帮助我们应对更多的情况。这篇文章将介绍逆向中常见的单项散列算法和对称加密算法的识别方法。 0xFF. 前言 在很长一段时间里我经常发现自己面对复杂的加密算法无从下手，可能是因为还没有系统学过密码学吧orz，总之这个问题困扰了我很久。于是最近我花了一些时间来解决自己在密码学这块的薄弱点，写下这篇文章的目的之一也是为了巩固所学知识。 加密算法的部分没有
散列表的设计与实现
11-07
散列表是一种存储结构，是和链表，数组不同的存储结构，其存储位置是有存储数据而定的，本题中，有学生姓名、住址和电话号码，输入学生姓名，将拼音字母转化成阿克斯码，将所有的阿克斯码加起来与20取余数得到的数字是该数据的存储位置，电话号码是是直接数字相加与20取余数得到的存储地址，可以实现学生的记录添加，查找记录删除记录和现实所有记录等功能。
C语言实现散列表（哈希Hash表)实例详解
08-30
主要介绍了C语言实现散列表（哈希Hash表)实例详解的相关资料,需要的朋友可以参考下
数据结构课设（散列表的设计与实现）
08-10
数据结构课设，散列表的设计与实现，包含说明书与源代码
哈希表的设计与实现（C语言课程设计）
11-19
本人使用C语言做的一个哈希表的课程设计，希望对大家有用。
C语言指导书 数据结构随堂笔记 散列表 排序汇总
04-20
C语言指导书 数据结构随堂笔记 散列表 排序汇总 经典
Redis（基于狂神说Java-Redis）
weixin_46468474的博客
11-19 4412
最近在进行Redis二刷，看了B站狂神的视频，纯手写的方式做了一个总结，如果这篇文章有帮到你，也希望能够多多支持，也支持一下狂神狂宝宝的视频，一起加油，继续努力！ 什么是NoSQL？ 为什么要用NoSQL？ 先从历史开始讲吧 1、单机数据库时代 90年代，一个基本的网站访问量较小，单个数据库可以顶住当时的访问量 在那个时候，都会去使用静态网页html，因为服务器压力不会太大 缺点： 数据量太大，一台机子放不下了 当数据量达到300万以上，就需要建立索引，MySQL索引，B+树。数据量一大，电脑内存.
C语言写一个散列表
微小冷的学习笔记
12-30 2620
文章目录快速理解散列表散列函数防撞 快速理解散列表 散列表，就是下标可以为字母的数组。 假设现有一个数组int a[100]，想查找其中第40个元素，则直接输入a[40]就可以了，时间复杂度为O(1)O(1)O(1)。 问题在于，当下标不是数字，而是一个字符串的时候，可能需要一个超大的空间才能将所有下标妥善地存放在特定的位置。例如，若以大小写字母作为下标索引，那么一位就需要预留52个空间，10位就需要521052^{10}5210这么大的空间，根本没有设备可以满足。 好在，521052^{10}5210这么
散列表/哈希表(C语言简单实现)
DFGOMC的博客
11-24 5121
散列表/哈希表(C语言简单实现) 本文参考自《大话数据结构》 定义 通过某个函数f计算出记录的存储位置，而不需要通过比较，这就是一种新的存储技术——散列技术。 散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key) 。在查找时，根据这个确定的对应关系找到给定值key的映射f(key)，若查找集合中存在这个记录，则必定在f(key)的位置上。 我们把这种对应关系f称为散列函数，又称为哈希函数。按照这个思路，采用散列技术将记录存储在一块连续的存储
散列表（哈希表)总结（C语言)
奋斗的龙猫的博客
05-04 3497
散列表
C语言描述：数据结构与算法分析入门指南
《数据结构与算法分析：C语言描述》是一本由Mark Allen Weiss编著的经典计算机科学著作，专注于探讨数据结构和算法的基础理论以及如何用C语言进行实践应用。该书适合对编程和算法有兴趣的读者，特别是那些想要深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值