哈希表

//.h
#pragma once
#include <assert.h>

template <class TVALUE>
class CHash_Table
{
public:
	CHash_Table( int nSize = 100);
	~CHash_Table(void);

public:
	bool    InsertItem(int Key, TVALUE Value);
	bool    DeleteItem(int Key);
	TVALUE* FindItem(int Key);

private:
	int     HashFuncation(int Key);

private:
	typedef struct _HASHNODE
	{
		int        m_Key;
		TVALUE     m_Value;
		_HASHNODE* m_pNext;
	}HASHNODE;

	int		    m_nHashTableSize;
	HASHNODE**  m_pHashTable;
};

template <class TVALUE>
CHash_Table<TVALUE>::CHash_Table( int nSize/* = 100 */ )
{
	assert(nSize > 0);

	m_nHashTableSize = nSize;
	m_pHashTable     = new HASHNODE*[m_nHashTableSize];

	assert (m_pHashTable != NULL);

	for (int i = 0; i < m_nHashTableSize; i++)
	{
		m_pHashTable[i] = NULL;
	}
}

template <class TVALUE>
CHash_Table<TVALUE>::~CHash_Table( void )
{
	for (int i = 0; i < m_nHashTableSize; i++)
	{
		if (m_pHashTable[i] != NULL)
		{
			HASHNODE *pTmp = m_pHashTable[i];

			while (pTmp != NULL)
			{
				m_pHashTable[i] = pTmp->m_pNext;
				delete pTmp;

				pTmp = m_pHashTable[i];
			}
		}
	}
}

template <class TVALUE>
bool CHash_Table<TVALUE>::InsertItem( int Key, TVALUE Value )
{
	int nPos = HashFuncation(Key);

	HASHNODE *pNewNode = new HASHNODE;
	if (pNewNode == NULL)
		return false;

	pNewNode->m_Key    = Key;
	pNewNode->m_Value  = Value;
	pNewNode->m_pNext  = m_pHashTable[nPos];

	m_pHashTable[nPos] = pNewNode;

	return true;
}

template <class TVALUE>
bool CHash_Table<TVALUE>::DeleteItem( int Key )
{
	int nPos = HashFuncation(Key);

	HASHNODE *pPreNode = m_pHashTable[nPos];
	HASHNODE *pCurNode = m_pHashTable[nPos];

	while (pCurNode != NULL && pCurNode->m_Key != Key)
	{
		pPreNode = pCurNode;
		pCurNode = pCurNode->m_pNext;
	}

	if (pCurNode != NULL && pCurNode->m_Key == Key)
	{
		pPreNode->m_pNext = pCurNode->m_pNext;
		delete pCurNode;

		return true;
	}
		
	return false;
}

template <class TVALUE>
TVALUE* CHash_Table<TVALUE>::FindItem( int Key )
{
	int nPos = HashFuncation(Key);

	HASHNODE *pArry = m_pHashTable[nPos];

	while (pArry != NULL && pArry->m_Key != Key)
	{
		pArry = pArry->m_pNext;
	}

	if (pArry != NULL)
		return &pArry->m_Value;
	else
		return NULL;
}

template <class TVALUE>
int CHash_Table<TVALUE>::HashFuncation( int Key )
{
	int nFlg = Key>>31;
	Key = (Key^nFlg) - nFlg;  //求绝对值 

	return Key % m_nHashTableSize;
}

 

//.cpp
void TestHashTable()
{
	CHash_Table<int> HashTable(20);

	for (int i = 0; i < 80; i++)
		HashTable.InsertItem(i, rand() % 100);

	HashTable.InsertItem(-90, rand() % 100);

	int *pValue = NULL;
	pValue = HashTable.FindItem(10);
	pValue = HashTable.FindItem(80);

	bool bSuccess = false;
	bSuccess = HashTable.DeleteItem(50);
	bSuccess = HashTable.DeleteItem(80);
}