重复发明轮子 自己实现哈希表。

Posted bywayboy

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了重复发明轮子 自己实现哈希表。相关的知识，希望对你有一定的参考价值。

      首先想用汇编写的。但写到最后晕头转向。没办法。先用C++验证一遍自己的思路吧。代码如下。

 

  2. CHashMap::CHashMap()
  3. {
  4.     m_size  = 100;
  5.     m_count = 0;
  6.     m_nodes = (PCNODE)malloc(sizeof(CNODE)*100);
  7.     ZeroMemory(m_nodes,sizeof(CNODE)*100);
  8. }
  10. CHashMap::~CHashMap()
  11. {
  12.     for(int i=0;i<m_size;i++)
  13.     {
  14.         PCNODE cur_node = m_nodes+i;
  15.         if(cur_node->left)
  16.             _Del_X(cur_node->left);
  17.         if(cur_node->right)
  18.             _Del_X(cur_node->right);
  19.     }
  20.     free(m_nodes);
  21. }
  23. BOOL CHashMap::Set(DWORD key,DWORD value)
  24. {
  25.     if(m_count/m_size>=0.72)
  26.     {
  27.         // 重建哈希表 尺寸是原来的哈希表的双倍。
  28.         DWORD new_size  = m_size*2;
  29.         PCNODE  new_nodes   =  (PCNODE)malloc(sizeof(CNODE)*new_size);
  30.         ZeroMemory(new_nodes,sizeof(CNODE)*new_size);
  31.         for(int i=0;i<m_size;i++)
  32.         {
  33.             PCNODE cur_node = m_nodes+i;
  34.             if(cur_node->key)
  35.             {
  36.                 //添加当前节点。
  37.                 PCNODE add_node = _GetAddress_X(new_nodes,new_size,cur_node->key);
  38.                 if(add_node) add_node->value=cur_node->value;
  40.                 //遍历子节点，并且要删除旧的。
  41.                 if(cur_node->right)
  42.                     _SetAndDel_X(new_nodes,new_size,cur_node->right);
  43.                 if(cur_node->left)
  44.                     _SetAndDel_X(new_nodes,new_size,cur_node->left);
  45.             }
  46.         }
  47.         //删除旧的.
  48.         free(m_nodes);
  49.         m_nodes = new_nodes;
  50.         m_size = new_size;
  51.     }
  53.     PCNODE node;
  54.     if(node= _GetAddress_X(m_nodes,m_size,key))
  55.     {
  56.         node->value=value;
  57.         m_count++;
  58.         return TRUE;
  59.     }
  60.     return FALSE;
  61. }
  63. DWORD CHashMap::Get(DWORD key)
  64. {
  65.     // 先定位到数据。比较键值，寻找节点。最后返回需要的值。
  66.     DWORD pos= key % m_size;
  67.     PCNODE node=m_nodes+pos;
  68.     while(node){
  69.         if(key>node->key)
  70.             node = node->right;
  71.         else if(key<node->key)
  72.             node = node->left;
  73.         else
  74.             return node->value;
  75.     }
  76.     return NULL;
  77. }
  79. BOOL CHashMap::Exists(DWORD key)
  80. {
  81.     DWORD pos= key % m_size;
  82.     PCNODE node=m_nodes+pos;
  83.     while(node){
  84.         if(key>node->key)
  85.             node = node->right;
  86.         else if(key<node->key)
  87.             return TRUE;
  88.         else
  89.             return node->value;
  90.     }
  91.     return FALSE;
  92. }
  93. BOOL CHashMap::Del(DWORD key)
  94. {
  95.     DWORD pos= key % m_size;
  96.     PCNODE par_node = NULL,cur_node,node=m_nodes+pos;
  97.     if(NULL == node->key) return FALSE;
  98.     while(node){
  99.         
  100.         if(key>node->key){
  101.             par_node = node;
  102.             node = node->right;
  103.         }else if(key<node->key){
  104.             par_node = node;
  105.             node = node->left;
  106.         }else{
  107.             cur_node = node;
  108.             break;
  109.         }
  110.     }
  111.     if(!node) return FALSE; //没有找到 返回了
  113.     if(!par_node) //根节点的情况
  114.     {
  115.         if (cur_node->right)
  116.         {
  117.             PCNODE left_node = cur_node->left;
  118.             *cur_node = *cur_node->right;
  119.             if(left_node){
  120.                 //挂到最左边去。
  121.                 while(cur_node->left){
  122.                     cur_node = cur_node->left;
  123.                 }
  124.                 cur_node->left = left_node;
  125.             }
  126.         }else if(cur_node->left)
  127.         {
  128.             //没有右边节点的情况.
  129.             *cur_node = *cur_node->left;
  130.         }else{
  131.             //啥也没有的情况
  132.             cur_node->value = cur_node->key = 0;
  133.             cur_node->left=cur_node->right=NULL;
  134.         }
  135.         return TRUE;
  136.     }
  137.     /* 不是根节点的情况 需要 释放 cur_node*/
  138.     if(cur_node->right){
  139.         par_node->right=cur_node->right;
  140.         //左边的节点挂到右边的最左边。
  141.         if(cur_node->left){
  142.             node = cur_node;
  143.             while(node->left){node=node->left;}
  144.             node->left=cur_node->left;
  145.         }
  146.     }else if(cur_node->left){
  147.         //不存在右边的情况。
  148.         par_node->left=cur_node->left;
  149.     }else
  150.     {
  151.         if(par_node->left == cur_node)
  152.             par_node->left=NULL;
  153.         else
  154.             par_node->right=NULL;
  155.     }
  156.     free(cur_node);
  157.     return TRUE;
  158. }
  160. // 这是一个静态方法，复制新的节点，并删除旧的节点。
  161. void CHashMap::_SetAndDel_X(PCNODE arg_nodes,DWORD arg_size,PCNODE arg_node)
  162. {
  163.     PCNODE add_node = _GetAddress_X(arg_nodes,arg_size,arg_node->key);
  164.     if(add_node) add_node->value=arg_node->value;
  166.     if(arg_node->right)
  167.         _SetAndDel_X(arg_nodes,arg_size,arg_node->right);
  168.     if(arg_node->left)
  169.         _SetAndDel_X(arg_nodes,arg_size,arg_node->left);
  170.     free(arg_node);
  171. }
  173. void CHashMap::_Del_X(PCNODE arg_node)
  174. {
  176.     if(arg_node->right)
  177.         _Del_X(arg_node);
  178.     if(arg_node->left)
  179.         _Del_X(arg_node);
  180.     free(arg_node);
  181. }
  182. /*
  183.     如果相同键值的数据存在，会返回空。
  184.     这个方法是静态的。
  185.     如果存在，它会给我一个空间。如果不存在。它会分配好一个新的地址。
  186. */
  187. PCNODE CHashMap::_GetAddress_X(PCNODE arg_node,DWORD arg_size,DWORD key)
  188. {
  189.     DWORD pos= key % arg_size;
  190.     PCNODE t_node,node=arg_node+pos;
  191.     if(node->key==0){
  192.         node->key = key;
  193.         return node;
  194.     }
  195.     while (node)
  196.     {
  197.         t_node = node;
  198.         if(key>node->key)
  199.             node=node->right;
  200.         else if(key == node->key)
  201.             return NULL;
  202.         else
  203.             node=node->left;
  204.     }
  205.     node = (PCNODE)malloc(sizeof(CNODE));
  206.     node->key=key;node->left=node->right = NULL;
  207.     if(key>t_node->key)
  208.         t_node->right = node;
  209.     else
  210.         t_node->left = node;
  211.     return node;
  212. }

头文件:

 

  1. class CHashMap  
  2. {
  3. public:
  4.     CHashMap();
  5.     BOOL Set(DWORD key,DWORD value);//设置数据
  6.     DWORD Size(){return m_size;}    //取容量尺寸
  7.     DWORD Count(){return m_count;}  //取数据数目
  8.     DWORD Get(DWORD key);           //取数据
  9.     BOOL  Del(DWORD key);           //删除数据
  10.     BOOL Exists(DWORD key);         //数据是否存在
  11.     virtual ~CHashMap();
  13. private:
  14.     static PCNODE _GetAddress_X(PCNODE arg_node,DWORD arg_size,DWORD key);
  15.     static void _SetAndDel_X(PCNODE arg_nodes,DWORD arg_size,PCNODE arg_node);
  16.     void _Del_X(PCNODE arg_node);
  17. protected:
  18.     DWORD m_size;
  19.     DWORD m_count;
  20.     PCNODE m_nodes;
  21. };

以上是关于重复发明轮子 自己实现哈希表。的主要内容，如果未能解决你的问题，请参考以下文章

自己动手实现java数据结构哈希表

leetcode 数据结构 探索哈希表

哈希表原理及简单设计

[Codevs 1230]元素查找(手写哈希表)

STL 是不是包含哈希表？ [复制]

redis源码学习看看redis的“哈希表”实现