应用散列表和外拉链表统计文本中单词个数

最新推荐文章于 2022-05-22 11:22:42 发布
最新推荐文章于 2022-05-22 11:22:42 发布
阅读量842 收藏
点赞数
文章标签： c语言 算法 链表 c hash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012410778/article/details/24121827
版权

应用散列表和外拉链表统计英文单词个数, 其中外拉链表用的是双向链表模板, 散列表是一个大数组, hash 函数有 BKDRHash,  APHash, DJBHash, PJWHash, ELFHash等多种Hash函数. 测试性能主要是测试平均外链长度和槽占用率. 这里选择的英文文章是ANSI格式的, 因为英文文章里标点符号后面会加空格, 所以这段代码截取单词时以空格为标志, 然后再去除截取单词中的标点符号.

llgen.h

/*----- hash.h ----------------------------------------------------------------
*  Declarations for hash table and external chaining.
*  Used in conjunction with hash.c
*---------------------------------------------------------------------------*/
#ifndef LLGEN_H 
#define	LLGEN_H 1

struct Node {
	struct Node * prev;
	struct Node * next;
	void        * data;   /* generic pointer to data */
};

typedef struct Node * Link;

/* a linked-list data structure */
struct List {
	Link LHead;
	Link LTail;
	unsigned int LCount;
	void * ( *LCreateData )      ( void * data );
	int    ( *LDeleteData )      ( void * data );
	int    ( *LDuplicatedNode )  ( Link new_node , Link list_node );
	int    ( *LNodeDataCmp )     ( void * first , void * second );
};



/*--- generic linked-list primitives ---*/
int AddNodeAtHead( struct List * LList , void * data_add );
int AddNodeAscend( struct List * LList , void * data_add );

struct List * CreateLList(
	void * ( *LCreateData )      ( void * data ) ,
	int    ( *LDeleteData )      ( void * data ) ,
	int    ( *LDuplicatedNode )  ( Link new_node , Link list_node ) ,
	int    ( *LNodeDataCmp )     ( void * first , void * second ) );

Link CreateNode( struct List * LList , void * data_create );
int  DeleteNode( struct List * LList , Link node_delete );
Link FindNode( struct List * LList , void * data_search );
Link FindNodeAscend( struct List * LList , void * data_search );




#endif

llapp.h 

#ifndef LLAPP_H 
#define LLAPP_H 1

struct WordNode {
	char * word;
	unsigned int word_count;
};


void * CreateData      ( void * data );
int    DeleteData      ( void * data );
int    DuplicatedNode  ( Link new_node , Link list_node );
int    NodeDataCmp     ( void * first , void * second );

#endif

hash_table.h 

/*--- the hash table portion ---*/

#ifndef HASH_H 
#define	HASH_H 1

#include "llgen.h"

int CreateHashTable( Link ** table_create );

#endif


hash_functions.h 

#ifndef HASH_FUNCTIONS_H 
#define HASH_FUNCTIONS_H 1

unsigned int BKDRHash( char *str );

unsigned int APHash( char *str );

unsigned int SDBMHash( char *str );

unsigned int RSHash( char *str );

unsigned int JSHash( char *str );

unsigned int PJWHash( char *str );

unsigned int ELFHash( char *str );

unsigned int DJBHash( char *str );

#endif

llgen.cpp 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "llgen.h"

/*--- Aliases to make the code more readable ---*/

#define LLHead         ( LList->LHead )
#define LLTail         ( LList->LTail )
#define NodeCount      ( LList->LCount )

#define CreateData     ( LList->LCreateData )
#define DeleteData     ( LList->LDeleteData )
#define DuplicatedNode ( LList->LDuplicatedNode )
#define NodeDataCmp    ( LList->LNodeDataCmp )



/*-----------------------------------------------------------------------------
 *  Add a node at head: first allocate the space for the data, then allocate 
 *  a node with a pointer to the data, then add the node to the list.
 *  Return 0 on error, 1 on success.
 *---------------------------------------------------------------------------*/
int AddNodeAtHead( struct List * LList , void * data_add )
{
	Link pnode;

	pnode = CreateNode( LList , data_add );
	if ( NULL == pnode ) {
		return ( 0 );
	}

	/* Add the node */
	if ( NULL == LLHead ) {         /* Is it the first node? */
		LLHead = LLTail = pnode;    /*--- yes ---*/
	}
	else {                          /*--- no  ---*/
		pnode->next = LLHead;
		LLHead->prev = pnode;
		LLHead = pnode;
	}

	NodeCount += 1;
	return ( 1 );
}


/*-----------------------------------------------------------------------------
 *  Add Ascending. Adds a node to an ordered list.
 *---------------------------------------------------------------------------*/
int AddNodeAscend( struct List * LList , void * data_add )
{
	Link pnode;
	struct Node dummy;   /* a dummy node */
	Link prev , curr;    /* our current search */
	int  compare_status;
	int  duplicate_status;

	pnode = CreateNode( LList , data_add );
	if ( NULL == pnode ) {
		return ( 0 );
	}

	/* attach dummy node to head of list */
	dummy.next = LLHead;
	dummy.prev = NULL;
	if ( NULL != dummy.next ) {
		dummy.next->prev = &dummy;
	}
	prev = &dummy;
	curr = dummy.next;

	/* search position to add node */
	for ( ; NULL != curr ; prev = curr , curr = curr->next ) {
		compare_status = NodeDataCmp( data_add , curr->data );
		if ( compare_status <= 0 ) {
			break;
		}
	}

	/* handle duplicated node */
	if ( NULL != LLHead && 0 == compare_status ) {
		duplicate_status = DuplicatedNode( pnode , curr );
		if ( 2 == duplicate_status ) {
			/* do nothing -- will get inserted */
		}
		else {
			/* same as 0 == duplicate_status, do nothing to list, function return */
			/* first, repair the linked-list */
			LLHead = dummy.next;
			LLHead->prev = NULL;

			if ( 1 == duplicate_status ) {
				DeleteData( pnode->data );
				free( pnode );
			}
			return ( 1 );
		}
	}

	/* Add the node */
	pnode->next = curr;
	pnode->prev = prev;
	prev->next = pnode;
	if ( NULL != curr ) {
		curr->prev = pnode;
	}
	else {
		LLTail = pnode;   /* this node is the new tail */
	}

	NodeCount += 1;
	/* now, unhook the dummy head node */
	LLHead = dummy.next;
	LLHead->prev = NULL;
	return ( 1 );
}

/*-----------------------------------------------------------------------------
 *  Creates a linked-list structure and returns a pointer to it.
 *  This functions accepts pointers to the four list-specific functions and 
 *  initializes the linked-list structure with them.
 *  Return NULL on errors, a pointer to linked-list on success.
 *---------------------------------------------------------------------------*/
struct List * CreateLList(
	void * ( * LCreateData )      ( void * data ),
	int    ( * LDeleteData )      ( void * data ),
	int    ( * LDuplicatedNode )  ( Link new_node , Link list_node ),
	int    ( * LNodeDataCmp )     ( void * first , void * second ) )
{
	struct List * plist;
	plist = ( struct List * )malloc( sizeof ( struct List ) );
	if ( NULL == plist ) {
		return ( NULL );
	}

	plist->LHead  = NULL;
	plist->LTail  = NULL;
	plist->LCount = 0;

	plist->LCreateData = LCreateData;
	plist->LDeleteData = LDeleteData;
	plist->LDuplicatedNode = LDuplicatedNode;
	plist->LNodeDataCmp = LNodeDataCmp;

	return ( plist );
}

/*-----------------------------------------------------------------------------
 *  Creates a node and then call the application-specific function CreateData()
 *  to create the node's data structure.
 *  Return NULL on error, a pointer to new created node on success.
 *---------------------------------------------------------------------------*/
Link CreateNode( struct List * LList , void * data_create )
{
	Link new_node;

	new_node = ( Link )malloc( sizeof( struct Node ) );
	if ( NULL == new_node ) {
		return ( NULL );
	}
	
	new_node->prev = NULL;
	new_node->next = NULL;

	/* now call the application-specific data allocation */
	new_node->data = CreateData( data_create );
	if ( NULL == new_node->data ) {
		free( new_node );
		return ( NULL );
	}

	return ( new_node );
}

/*-----------------------------------------------------------------------------
 *  Deletes the node pointed to by node_delete.
 *  Function calls list-specific function to delete data.
 *  Return 0 on error, 1 on success.
 *---------------------------------------------------------------------------*/
int DeleteNode( struct List * LList , Link node_delete )
{
	Link node;

	if ( NULL == node_delete ) {   /* empty linked-list */
		return ( 0 );
	}

	/* there is only one node in the linked-list? */
	if ( NULL == node_delete->prev && NULL == node_delete->next ) {
		LLHead = NULL;        /*--- yes ---*/
		LLTail = NULL;
	}
	else {                    /*--- no ---*/
		if ( NULL == node_delete )          /* we are at the head */
		{
			LLHead = node_delete->next;
			LLHead->prev = NULL;
		}
		else if ( NULL == node_delete )     /* we are at the tail */
		{
			LLTail = node_delete->prev;
			LLTail->next = NULL;
		}
		else {								/* we are in the list */
			node = node_delete->prev;
			node->next = node_delete->next;

			node = node_delete->next;
			node->prev = node_delete->prev;
		}
	}

	/* now delete the node */
	DeleteData( node_delete->data );
	free( node_delete );

	NodeCount -= 1;

	return ( 1 );
}


/*-----------------------------------------------------------------------------
 *  Finds node by starting at the head of the list, stepping through each node,
 *  and comparing data items with the search key. The Ascend Version checks that
 *  the data in the node being examined is not larger than the search key, 
 *  If it is , we know the key is not in the list.
 *  Return NULL on error, a pointer to target node on success.
 *---------------------------------------------------------------------------*/
Link FindNode( struct List * LList , void * data_search )
{
	Link curr;
	int  compare_status;
	for ( curr = LLHead; NULL != curr; curr = curr->next ) {
		compare_status = NodeDataCmp( data_search , curr->data );
		if ( 0 == compare_status ) {
			return ( curr );
		}
	}
	return ( NULL );   /* could not find node */
}

Link FindNodeAscend( struct List * LList , void * data_search )
{
	Link curr;
	int  compare_status;

	for ( curr = LLHead; NULL != curr; curr = curr->next ) {
		compare_status = NodeDataCmp( data_search , curr->data );
		if ( compare_status < 0 ) {
			return ( NULL );
		}
		if ( 0 == compare_status ) {
			return ( curr );
		}
	}

	return ( NULL );   /* could not find node */
}

llapp.cpp 

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
#include <string.h>

#include "llgen.h"
#include "llapp.h"


void * CreateData( void * data )
{
	struct WordNode * pword;
	pword  = ( struct WordNode * )malloc( sizeof( struct WordNode ) );
	if ( NULL == pword ) {
		return ( NULL );
	}
	
	pword->word_count = 1;
	pword->word = _strdup( ( (( struct WordNode * )data)->word ) );

	if ( NULL == pword->word ) {
		free( pword );
		return ( NULL );
	}
	else {
		return ( pword );
	}
}

/* free heap memory! here, data is a pointer to a structure or any other style */
int DeleteData( void * data )
{
	/* In this case, WordNode consists of: a pointer and an int.
	 * The integer will be returned to memory when the node is freed.
	 * However, the string must be freed manually.       
	 */
	free( ( ( struct WordNode * )data )->word );
	return ( 1 );
}

/*  This function determines what to do when inserting a node into a list if an 
 *  existing node with the same data is found in the list. In this case, since we 
 *  are counting words, if a duplicate word is found, we simply increment the counter.
 *
 *  Note this function should return one of the following values:
 *           0           an error occurred
 *           1           delete the duplicated node
 *           2           insert the duplicated node
 */
int DuplicatedNode( Link new_node , Link list_node )
{
	struct WordNode * wd = ( struct WordNode * )(list_node->data);
	++ wd->word_count;
	return ( 1 );
}

int NodeDataCmp( void * first , void * second )
{
	int compare_status;
	compare_status = strcmp( ( ( struct WordNode * )first  )->word ,
							 ( ( struct WordNode * )second )->word );
	return ( compare_status );
}


hash_table.cpp 

#include <stdlib.h>
#include "hash_table.h"

#define TABLE_SIZE	1000

/*-----------------------------------------------------------------------------
 *  The function accepts a multilevel pointer to the Node structure and modify it.
 *  Return 0 on error, 1 on success.
 *---------------------------------------------------------------------------*/
int CreateHashTable( Link ** table_create )
{
	*table_create = ( Link * )calloc( TABLE_SIZE , sizeof( Link ) );
	return ( NULL == *table_create ? 0 : 1 );
}

hash_functions.cpp 

// BKDR Hash Function
unsigned int BKDRHash( char *str )
{
	unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
	unsigned int hash = 0;

	while ( *str ) {
		hash = hash * seed + ( *str++ );
	}

	return ( hash & 0x7FFFFFFF );
}


// AP Hash Function
unsigned int APHash( char *str )
{
	unsigned int hash = 0;
	int i;

	for ( i=0; *str; i++ ) {
		if ( ( i & 1 ) == 0 ) {
			hash ^= ( ( hash << 7 ) ^ ( *str++ ) ^ ( hash >> 3 ) );
		}
		else {
			hash ^= ( ~( ( hash << 11 ) ^ ( *str++ ) ^ ( hash >> 5 ) ) );
		}
	}

	return ( hash & 0x7FFFFFFF );
}


// SDB Hash Function
unsigned int SDBMHash( char *str )
{
	unsigned int hash = 0;

	while ( *str ) {
		// equivalent to: hash = 65599*hash + (*str++);
		hash = ( *str++ ) + ( hash << 6 ) + ( hash << 16 ) - hash;
	}

	return ( hash & 0x7FFFFFFF );
}

// RS Hash Function
unsigned int RSHash( char *str )
{
	unsigned int b = 378551;
	unsigned int a = 63689;
	unsigned int hash = 0;

	while ( *str ) {
		hash = hash * a + ( *str++ );
		a *= b;
	}

	return ( hash & 0x7FFFFFFF );
}

// JS Hash Function
unsigned int JSHash( char *str )
{
	unsigned int hash = 1315423911;

	while ( *str ) {
		hash ^= ( ( hash << 5 ) + ( *str++ ) + ( hash >> 2 ) );
	}

	return ( hash & 0x7FFFFFFF );
}

// PJW Hash Function
unsigned int PJWHash( char *str )
{
	unsigned int BitsInUnignedInt = ( unsigned int )( sizeof( unsigned int )* 8 );
	unsigned int ThreeQuarters    = ( unsigned int )( ( BitsInUnignedInt  * 3 ) / 4 );
	unsigned int OneEighth        = ( unsigned int )( BitsInUnignedInt / 8 );
	unsigned int HighBits         = ( unsigned int )( 0xFFFFFFFF ) << ( BitsInUnignedInt - OneEighth );
	unsigned int hash             = 0;
	unsigned int test             = 0;

	while ( *str ) {
		hash = ( hash << OneEighth ) + ( *str++ );
		if ( ( test = hash & HighBits ) != 0 ) {
			hash = ( ( hash ^ ( test >> ThreeQuarters ) ) & ( ~HighBits ) );
		}
	}

	return ( hash & 0x7FFFFFFF );
}

// ELF Hash Function
unsigned int ELFHash( char *str )
{
	unsigned int hash = 0;
	unsigned int x    = 0;

	while ( *str ) {
		hash = ( hash << 4 ) + ( *str++ );
		if ( ( x = hash & 0xF0000000L ) != 0 ) {
			hash ^= ( x >> 24 );
			hash &= ~x;
		}
	}

	return ( hash & 0x7FFFFFFF );
}



// DJB Hash Function
unsigned int DJBHash( char *str )
{
	unsigned int hash = 5381;

	while ( *str ) {
		hash += ( hash << 5 ) + ( *str++ );
	}

	return ( hash & 0x7FFFFFFF );
}

Main.cpp 

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>      /* include isspace ispunct */

#include "hash_functions.h"
#include "llgen.h"
#include "llapp.h"
#include "hash_table.h"


#define TABLE_SIZE	1000


void PrintHashTable( Link * HashTable );
void PrintHashTableStates( Link * HashTable , struct List * chain_list );

int main( int argc , char * argv[] )
{
	char word[64] = "";
	char *low_word;
	int c , i;
	int  add_status;
	unsigned int hash_key;
	struct List * chain_list;
	struct WordNode tmp_word_node;
	Link * HashTable;  /* Our table is an array of Links */
	FILE *fileRead;

	/* open the file for read */
	fileRead = fopen( "English.txt" , "rt" );
	if ( NULL == fileRead ) {
		fprintf( stderr , "Failed Open English.txt!\n" );
		return ( EXIT_FAILURE );
	}

	/* create the hash table */
	if ( 0 == CreateHashTable( &HashTable ) ) {
		fprintf( stderr , "Failed CreateHashTable!\n" );
		return ( EXIT_FAILURE );
	}

	/* set up linked-list data structure */
	chain_list = CreateLList( CreateData , DeleteData , DuplicatedNode , NodeDataCmp );
	if ( NULL == chain_list ) {
		fprintf( stderr , "Failed CreateLList!\n" );
		return ( EXIT_FAILURE );
	}

	c = ' ';
	/*--- Begin processing file ---*/
	while ( !feof( fileRead ) ) {
		/* skip white space */
		while ( EOF != c && isspace( c ) ) {
			c = fgetc( fileRead );
		}

		/* pick up the word */
		i = 0;
		while ( EOF != c && !isspace( c ) ) {
			word[i++] = ( char )c;
			c = fgetc( fileRead );
		}
		word[i] = '\0';

		/* strip off trailing punctuation */
		while ( i >= 0 && ispunct( word[--i] ) ) {
			word[i] = '\0';
		}

		low_word = _strlwr( word );

		/* get the hash value */
		hash_key = ( unsigned int )DJBHash( low_word );
		hash_key = hash_key % TABLE_SIZE;

		/* insert into table */
		chain_list->LHead = HashTable[hash_key];
		tmp_word_node.word = _strdup( low_word );
		tmp_word_node.word_count = 1;

		add_status = AddNodeAscend( chain_list , &tmp_word_node );
		if ( 0 == add_status ) {
			fprintf( stderr , "Failed AddNodeAscend!\n" );
			return ( EXIT_FAILURE );
		}
		

		HashTable[hash_key] = chain_list->LHead;
		free( tmp_word_node.word );
	}

//	PrintHashTable( HashTable );
	PrintHashTableStates( HashTable , chain_list);
	fclose( fileRead );
}


/* printf the words in hash table */
void PrintHashTable( Link * HashTable )
{
	int i;
	Link curr;
	for ( i = 0; i < TABLE_SIZE; i ++ ) {
		if ( NULL != HashTable[i] ) {      /* print the word in the chain list */
			for ( curr = HashTable[i]; NULL != curr; curr = curr->next ) {
				printf( "%s -- %d\n" , ( (struct WordNode *)(curr->data) )->word , 
						( ( struct WordNode * )(curr->data) )->word_count );
			}
			printf( "\n\n" );
		}
	}
}

void PrintHashTableStates( Link * HashTable , struct List * chain_list )
{
	int i = 0;
	int chain_len , chains_total;
	int chain_table[33];
	Link pcurr;

	memset( chain_table , 0 , sizeof( int )* 33 );
	/* preprocessing the hash table */
	for ( i = 0; i < TABLE_SIZE; i ++ ) {
		pcurr = HashTable[i];
		if ( NULL != pcurr ) {  /* skip empty slots */

			for ( chain_len = 0 ; NULL != pcurr ; pcurr = pcurr->next ) {
				chain_len ++;
			}

			if ( chain_len > 32 ) {
				chain_len = 32;
			}

			chain_table[chain_len] += 1;
		}
	}

	/* list hash table states */
	chains_total = 0;

	for ( i = 32; i > 0; i -- ) {
		if ( 0 != chain_table[i] ) {
			printf( "%3d chains of length %2d\n" , chain_table[i] , i );
			chains_total += chain_table[i];
		}
	}

	if ( 0 != chains_total ) {
		printf( "\n%d nodes in %d chains \n\n" , 
				chain_list->LCount , chains_total );

		printf( "Size of hash table = %d \n" , TABLE_SIZE );

		printf( "Average chain length  = %f\n" , 
				chain_list->LCount / (( double )chains_total) );

		printf( "Slot occupancy = %f\n" , 
				(( double )chains_total) / TABLE_SIZE );

	}
}


我这里选择的英文文章不是很大,但可以看得出各种 Hash 算法的优劣. 我这里贴两个算法的比较 ELFHash 和 DJBHash

ELFHash:


DJBHash:



虽然实验不是很标准, 但可以看出两种散列算法的效果了




dq_zhx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
散列表的概念及其拉链法和常见的散列函数（C语言）
派拉斯兔子的博客
08-11 2985
一、散列查找 （一）散列表（Hash Table） 散列表（Hash Table），又称哈希表。是⼀种数据结构，特点是：数据元素的关键字与其存储地址直接相关 若不同的关键字通过散列函数映射到同⼀个值，则称它们为“同义词” 通过散列函数确定的位置已经存放了其他元素，则称这种情况为“冲突” （二）处理冲突的方法——拉链法 用拉链法（又称链接法、链地址法）处理“冲突”：把所有“同义词”存储在一个链表中
散列表的拉链法解决冲突c语言实现
A315776的博客
12-24 3406
#define N 12 //首先定义相关的结构体 typedef struct HNode { int key; struct HNode *next; }Hnode; /* 创建哈希表 heahLink哈希表，里面存储的为指针变量 key关键字列表 n关键字数目 */ void createHB(Hnode *heahLink[], int key[], int n) { ...
ACWING 840. 模拟散列表 (哈希)
3000bookworm
08-09 326
维护一个集合，支持如下几种操作： I x，插入一个数 x； Q x，询问数 x 是否在集合中出现过； 现在要进行 N 次操作，对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N，表示操作数量。 接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。 输出格式 对于每个询问指令 Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。 每个结果占一行。 数据范围 1≤N≤105 −109≤x≤109 输入样例： 5 I 1 I 2 I 3 Q 2
数据结构与算法之散列表（拉链法解决散列冲突）
weixin_61638947的博客
05-22 1580
自己手撸了一下拉链法解决散列冲突的算法，代码如下： #include <iostream> #include <vector> #define N 1000 using namespace std; typedef struct ChainNodes { int data; ChainNodes* Next; }ChainNodes; void CreatHashTable(vector<ChainNodes*>& try01) {
双向链表
aohuashan的专栏
01-08 277
*-------------------------------------------------------------*/ #ifndef LLGEN_H /* make sure it's included only once */ #define LLGEN_H 1 struct Node { struct Node *prev; ...
zifuchuan.rar_统计 串中 单词 个数
09-22
本示例中，我们关注的是如何统计一个字符串中单词的个数，并将这些单词提取出来存储到一个数组中。这个任务涉及到字符串处理、正则表达式、遍历以及数组操作等基础知识。接下来，我们将深入探讨这些知识点。 首先，...
python统计文本文件内单词数量的方法
09-22
接着，为了统计文本中的行数、空行数、句子数和单词数，我们需要初始化一些计数器，例如`lines`, `blanklines`, `sentences`, 和 `words`。这些变量在遍历文件内容时会被逐个增加。 在循环中，`for line in textf:`...
Python实现统计英文单词个数及字符串分割代码
09-22
在Python编程语言中，统计英文单词个数和字符串分割是常见的文本处理任务。这里我们将详细探讨这两种操作的实现方法。 首先，让我们来看一下如何进行字符串分割。在Python中，`str.split()` 方法是用于将字符串分割...
python实现统计文本中单词出现的频率详解
09-19
在Python编程中，统计文本中单词出现的频率是一项常见的任务，特别是在自然语言处理（NLP）和文本分析领域。这个任务可以帮助我们理解文本的主要主题、关键词以及词汇的分布情况。下面将详细解释如何使用Python实现...
python统计文本字符串里单词出现频率的方法
09-22
在Python编程中，统计文本字符串中单词出现的频率是一项非常实用的功能，尤其在自然语言处理、文本分析等领域有着广泛的应用。本文将详细介绍如何利用Python来实现这一功能，并深入探讨其中涉及到的字符串操作技巧。...
哈希表的开散列法（拉链法）
龙跃十二
03-01 7235
开散列法又叫链地址法(开链法)。 开散列法：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。 设元素的关键码为37, 25, 14, 36, 49, 68, 57, 11, 散列表为HT[12]，表的大小为12，散列函数为Hash(x) = x % 11 Hash(37)=...
基于拉链法的散列表(来自:算法)
weixin_42480264的博客
09-15 1084
下列代码主要实现了基于拉链法的散列表的添加元素put(),查找元素get(),删除元素delete(),遍历元素keys()等方法,我们需要首先根据元素值调用hash()方法找到该元素所对应的数组,而每一个数组都是一个链表,遍历链表,若元素不存在,则可以实现元素的添加,若存在,则可以实现元素的更新,删除等操作. 对于每一条链表的操作 package cn.edu.zzuli.api; im...
散列表（拉链式和线性探测）
huang1433的博客
01-05 836
无论是顺序查找还是二分查找（包括二叉树），查找或插入的时间复杂度总会与数据的总数N有关，而散列表可以将查找和插入操作降低到常数级别。 最简单的一种常数级别的符号表，就是直接将数据的键值作为数组的索引，通过键值就可以立即访问到数据，时间复杂度为1.但是这种方法有一个缺点就是键值的分布并不是平均的，而且跨度可能会很大，这样就会导致数组中很多空间被浪费了。 而散列表就是解决了这个缺点，将键值映射到均
Linux netfilter 学习笔记 之四 ip层netfilter的table注册及规则的添加
lickylin的专栏
06-22 6016
既然我们都已经将xt_table、rule、match、target的结构体之间的联系都已经分析清楚了，那我们接下来分析表的注册、表中规则的添加、表中规则的删除、表中规则的替换也应该比较容易了。   在上节分析时，我们应该有注意到一个细节，即xt_table_info->entries[]是指向每一个CPU对应于该xt_table的所有规则的首地址，而一个表里面所有的规则是按照连续内存存取的。
第三章--拉链法散列表
a219219219219的博客
07-29 467
public class SeparateChainingHashST<Key, Value> { /** * 这是拉链法散列表，同时利用了第三章最开始使用的链表实现的符号表。 * 使用数组的索引来表示符号表的key，为了解决key过大而导致的数组过大问题，利用hash方法对key进行处理，而处理后的key有可能会出现索引相同的现象，为了解决冲突，数组的值用链表来表示。 */ private int n; .
链表 的 增删改查（源码分析）
jxusthusiwen的专栏
09-19 927
链表 的 增删改查（源码分析）Code: #include     #include     #include        struct Node    {        char *City;        int Temp;        struct Node *Next;   
深入剖析printf函数(上)：如何不借助第三方库在屏幕上输出"Hello World"?
TCP/IP协议栈学习ing
01-11 8148
深入剖析printf函数(上) ---如何不借助第三方库实现printf函数？ (作者：LL   出处：http://blog.csdn.net/tcpipstack , 欢迎转载，也请保留这段声明。谢谢！) ---"你为什么要去登珠穆朗玛？"   当美国《纽约时报》记者问英国登山家乔治·马洛里。 ---“Because it is there(因为山在那里)
散列表-拉链法-
家里蹲大学摸鱼学专业优秀毕业生的博客
01-01 704
#include<stdio.h> #include<stdlib.h> #define M 11 typedef struct node { int pos; struct node* link; struct hashnode* branch; }HashTableNode; typedef struct hashnode { int key; struct hashnode* next; }HashNode; HashTableNode* NewHSTNode(i
《算法一》—单向链表
xidian208的专栏
04-23 392
算法 单向链表
python统计文本中不同单词个数
最新发布
05-24
可以用Python的字典来实现单词计数的功能，具体代码如下： ```python text = "This is a sample text with several words and repeated words" words = text.split() # 将文本划分成单词 word_count = {} # 创建一个空字典 # 遍历单词列表 for word in words: if word not in word_count: word_count[word] = 1 # 如果单词不在字典中，则将其加入字典，并将其计数设置为1 else: word_count[word] += 1 # 如果单词已经在字典中，则将其计数加1 # 输出不同单词的个数 print("不同单词的个数：", len(word_count)) ``` 输出结果如下： ``` 不同单词的个数： 9 ``` 这个代码可以统计文本中不同单词的个数，但是它并没有考虑到单词的大小写、标点符号等问题。如果需要更加精确的统计，还需要进行一些数据清洗的工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值