hash存储，序列化和调整大小平衡

最新推荐文章于 2020-06-12 17:44:53 发布
最新推荐文章于 2020-06-12 17:44:53 发布
阅读量903 收藏
点赞数 1
分类专栏： 综合 文章标签： 存储 class delete file include
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbingchenbing/article/details/7033880
版权
 

#include <cstdio>
#include <cstring>
#include "hashdict.h"


template<class KeyT,class CntT,class ValueT>
EA_COMMON::CHashDict<KeyT,CntT,ValueT>::CHashDict()
{}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::CHashDict<KeyT,CntT,ValueT>::~CHashDict()
{}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Create(CntT atHashNum,CntT atCnt)
{
 if(atHashNum == 0)
 {
  return enum_op_error;
 }
 
 m_oHashDict.m_tHashNum = atHashNum;
 m_oHashDict.m_tNodeNum = 0;
 m_oHashDict.m_tCnt = atCnt;
 
 m_oHashDict.m_oHashTbl.m_pHash = new STRU_HASH_DICT_NODE<KeyT,CntT,ValueT>*[m_oHashDict.m_tHashNum];
 if(!m_oHashDict.m_oHashTbl.m_pHash)
 {
  return enum_op_error;
 }
 
 memset(m_oHashDict.m_oHashTbl.m_pHash,0,sizeof(STRU_HASH_DICT_NODE<KeyT,CntT,ValueT>*)*m_oHashDict.m_tHashNum);
 
 m_oHashDict.m_pFirstBlock = new STRU_HASH_BLOCK<KeyT,CntT,ValueT>;
 if(!m_oHashDict.m_pFirstBlock)
 {
  delete [] m_oHashDict.m_oHashTbl.m_pHash;
  return enum_op_error;
 }
 
 memset(m_oHashDict.m_pFirstBlock->m_nHashNode,0,sizeof(STRU_HASH_DICT_NODE<KeyT,CntT,ValueT>)*HASH_DICT_BLOCK_NUM);
 m_oHashDict.m_pFirstBlock->m_pNext = 0;
 
 m_oHashDict.m_pCurBlock = m_oHashDict.m_pFirstBlock;
 m_oHashDict.m_uiAvailNum = HASH_DICT_BLOCK_NUM;
 m_oHashDict.m_pCurNode = m_oHashDict.m_pCurBlock->m_nHashNode;
 
 return enum_op_ok;
}

template<class KeyT,class CntT,class ValueT>
bool EA_COMMON::CHashDict<KeyT,CntT,ValueT>::IsDelNode(STRU_DICT_NODE<KeyT,CntT,ValueT> *aoNode)
{
 if(aoNode->m_tKey == 0)
 {
  return true;
 }
 
 return false;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Save(const char *apPath,const char *apFile)
{
 char lstrName[512];
 snprintf(lstrName,512,"%s/%s.info",apPath,apFile);
 
 //record info file
 FILE *lpFileInfo = fopen(lstrName,"w");
 fprintf(lpFileInfo,"hash_base=%u\nnode_num=%u\ncnt=%u\n",m_oHashDict.m_tHashNum,m_oHashDict.m_tNodeNum,m_oHashDict.m_tCnt);
 fclose(lpFileInfo);
 
 //record second level
 unsigned int *lpInfoCnt = new unsigned int[2*m_oHashDict.m_tHashNum];
 memset(lpInfoCnt,0,sizeof(unsigned int) * 2 * m_oHashDict.m_tHashNum);
 unsigned int *lpSkipCnt = lpInfoCnt;
 unsigned int *lpItemCnt = lpInfoCnt + m_oHashDict.m_tHashNum;

 unsigned int luiBlockCnt = 0,luiLoopCnt=0,luiNodeCnt=0;
 STRU_DICT_SAVE_NODE<KeyT,ValueT> *lpSave = new STRU_DICT_SAVE_NODE<KeyT,ValueT>[HASH_DICT_BLOCK_NUM];
 
 snprintf(lstrName,512,"%s/%s.data2",apPath,apFile);
 FILE *lpFileData2 = fopen(lstrName,"w");
 
 for(unsigned int i = 0;i < m_oHashDict.m_tHashNum;i++)
 {
  STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpHashNode = m_oHashDict.m_oHashTbl.m_pHash[i];
  
  lpSkipCnt[i] = luiNodeCnt;
  
  while(lpHashNode)
  {
   if(IsDelNode(lpHashNode))
   {
    lpHashNode = lpHashNode->m_pNext;
    continue;
   }
   
   lpSave[luiLoopCnt].m_tKey = lpHashNode->m_tKey;
   lpSave[luiLoopCnt].m_tValue = lpHashNode->m_tValue;
   
   lpItemCnt[i]++;
   luiLoopCnt++;
   luiNodeCnt++;
   
   if(luiLoopCnt >= HASH_DICT_BLOCK_NUM)
   {
    fwrite(lpSave,sizeof(STRU_DICT_SAVE_NODE<KeyT,ValueT>),luiLoopCnt,lpFileData2);
    luiBlockCnt++;
    luiLoopCnt=0;
   }
   
   lpHashNode = lpHashNode->m_pNext;
  }
 }
 
 if(luiLoopCnt != 0)
 {
  fwrite(lpSave,sizeof(STRU_DICT_SAVE_NODE<KeyT,ValueT>),luiLoopCnt,lpFileData2);
 }
 
 fclose(lpFileData2);
 delete [] lpSave;
 
 if((luiBlockCnt * HASH_DICT_BLOCK_NUM + luiLoopCnt != m_oHashDict.m_tNodeNum) || (luiNodeCnt != m_oHashDict.m_tNodeNum))
 {
  delete [] lpInfoCnt;
  return enum_op_error;
 }
 
 snprintf(lstrName,512,"%s/%s.data1",apPath,apFile);
 
 FILE *lpFileData1 = fopen(lstrName,"w");
 
 fwrite(lpSkipCnt,sizeof(unsigned int),m_oHashDict.m_tHashNum,lpFileData1);
 fwrite(lpItemCnt,sizeof(unsigned int),m_oHashDict.m_tHashNum,lpFileData1);
 
 fclose(lpFileData1);
 
 delete [] lpInfoCnt;
 
 m_oHashDict.m_tCnt++;
 
 return enum_op_ok; 
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Destroy()
{
 delete [] m_oHashDict.m_oHashTbl.m_pHash;
 
 STRU_HASH_BLOCK<KeyT,CntT,ValueT> *lpBlock = m_oHashDict.m_pFirstBlock;
 STRU_HASH_BLOCK<KeyT,CntT,ValueT> *lpTmp=0;;
 
 while(lpBlock)
 {
  lpTmp = lpBlock;
  lpBlock = lpBlock->m_pNext;
  delete [] lpTmp;
 }
 
 return enum_op_ok;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Load(const char *apPath,const char *apFile,CntT atHashNum)
{
 char lstrName[512];
 snprintf(lstrName,512,"%s/%s.info",apPath,apFile);
 
 FILE *lpFileInfo = fopen(lstrName,"r");
 
 unsigned int luiHashNum = 0,luiNodeNum = 0,luiCnt = 0;
 if(fscanf(lpFileInfo,"hash_base=%u\nnode_num=%u\ncnt=%u\n",&luiHashNum,&luiNodeNum,&luiCnt) != 3)
 {
  fclose(lpFileInfo);
  return enum_op_error;
 }
 
 fclose(lpFileInfo);
 
 luiHashNum = atHashNum > 0 ? atHashNum:luiHashNum;
 
 if(CHashDict<KeyT,CntT,ValueT>::Create(luiHashNum,0) != enum_op_ok)
 {
  return enum_op_error;
 }
 
 snprintf(lstrName,512,"%s/%s.data2",apPath,apFile);
 FILE *lpFileData2 = fopen(lstrName,"r");
 
 STRU_DICT_SAVE_NODE<KeyT,ValueT> loNodeValue[HASH_DICT_BLOCK_NUM];
 unsigned int luiNodeCnt = 0,luiNodeRCnt=0;
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> loDictNode;
 while((luiNodeCnt=fread(loNodeValue,sizeof(STRU_DICT_SAVE_NODE<KeyT,ValueT>),HASH_DICT_BLOCK_NUM,lpFileData2)) > 0)
 {
  for(int i = 0;i<luiNodeCnt;i++)
  {
   loDictNode.m_tKey = loNodeValue[i].m_tKey;
   loDictNode.m_tValue = loNodeValue[i].m_tValue;
   loDictNode.m_tCnt = -1;
   loDictNode.m_pNext = 0;
   
   Add(loDictNode,true);
  }
  
  luiNodeRCnt += luiNodeCnt;
 }
 
 fclose(lpFileData2);
 
 if(luiNodeRCnt != luiNodeNum)
 {
  return enum_op_error;
 }
 
 return enum_op_ok;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Add(STRU_DICT_NODE<KeyT,CntT,ValueT> &aoNode,bool abOverwrite)
{
 if(aoNode.m_tKey == 0)
 {
  return enum_add_invalid;
 }
 
 unsigned int luiKey = aoNode.m_tKey % m_oHashDict.m_tHashNum;
 
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpNode = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpInsNode=0,*lpAviNode=0;
 
 while(lpNode)
 {
  if(lpNode->m_tKey == aoNode.m_tKey)
  {
   lpInsNode = lpNode;
   break;
  }
  
  if(lpAviNode == 0 && lpNode->m_tKey == 0)
  {
   lpAviNode = lpNode;
  }
  
  lpNode = lpNode->m_pNext;  
 }
 
 ENUM_HASHDICT_OPTYPE loOpType = enum_op_ok;
 
 if(lpInsNode)
 {
  if(abOverwrite)
  {
   lpInsNode->m_tValue = aoNode.m_tValue;
   m_oHashDict.m_tCnt++;
   loOpType = enum_add_replace;
  }
  else
  {
   loOpType = enum_add_exist;
  }
 }
 else
 {
  if(lpAviNode)
  {
   lpAviNode->m_tKey = aoNode.m_tKey;
   lpAviNode->m_tValue = aoNode.m_tValue;
   lpAviNode->m_tCnt = ++m_oHashDict.m_tCnt;
   m_oHashDict.m_tNodeNum++;
  }
  else
  {
   if(m_oHashDict.m_uiAvailNum == 0)
   {
    m_oHashDict.m_pCurBlock = new STRU_HASH_BLOCK<KeyT,CntT,ValueT>;
    
    memset(m_oHashDict.m_pCurBlock->m_nHashNode,0,sizeof(STRU_HASH_DICT_NODE<KeyT,CntT,ValueT>) * HASH_DICT_BLOCK_NUM);
    
    m_oHashDict.m_pCurBlock->m_pNext = m_oHashDict.m_pFirstBlock;
    m_oHashDict.m_pFirstBlock = m_oHashDict.m_pCurBlock;
    m_oHashDict.m_uiAvailNum = HASH_DICT_BLOCK_NUM;
    m_oHashDict.m_pCurNode = m_oHashDict.m_pCurBlock->m_nHashNode;
   }
   
   lpInsNode = m_oHashDict.m_pCurNode;
   lpInsNode->m_pNext = 0;
   lpInsNode->m_tKey = aoNode.m_tKey;
   lpInsNode->m_tCnt = ++m_oHashDict.m_tCnt;
   lpInsNode->m_tValue = aoNode.m_tValue;
   
   if(m_oHashDict.m_oHashTbl.m_pHash[luiKey] == 0)
   {
    m_oHashDict.m_oHashTbl.m_pHash[luiKey] = lpInsNode;
   }
   else
   {
    lpInsNode->m_pNext = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
    m_oHashDict.m_oHashTbl.m_pHash[luiKey] = lpInsNode;
   }
   
   ++m_oHashDict.m_tNodeNum;
   --m_oHashDict.m_uiAvailNum;
   ++m_oHashDict.m_pCurNode;
  }
 }
 
 return loOpType; 
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Del(STRU_DICT_NODE<KeyT,CntT,ValueT> &aoNode)
{
 ENUM_HASHDICT_OPTYPE loOpType = enum_op_ok;
 
 unsigned int luiKey = aoNode.m_tKey % m_oHashDict.m_tHashNum;
 
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpNode = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
 
 while(lpNode)
 {
  if(lpNode->m_tKey == aoNode.m_tKey)
  {
   break;
  }
  
  lpNode = lpNode->m_pNext;
 }
 
 if(lpNode)
 {
  lpNode->m_tKey = 0;
  ++m_oHashDict.m_tCnt;
  --m_oHashDict.m_tNodeNum;
 }
 else
 {
  loOpType = enum_node_not_exist;
 }
 
 return loOpType;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Modify(STRU_DICT_NODE<KeyT,CntT,ValueT> &aoNode)
{
 ENUM_HASHDICT_OPTYPE loOpType = enum_op_ok;
 
 unsigned int luiKey = aoNode.m_tKey % m_oHashDict.m_tHashNum;
 
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpNode = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
 
 while(lpNode)
 {
  if(lpNode->m_tKey == aoNode.m_tKey)
  {
   break;
  }
  
  lpNode = lpNode->m_pNext;
 }
 
 if(lpNode)
 {
  lpNode->m_tValue = aoNode.m_tValue;
  lpNode->m_tCnt = ++m_oHashDict.m_tCnt;
 }
 else
 {
  loOpType = enum_node_not_exist;
 }
 
 return loOpType;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Find(STRU_DICT_NODE<KeyT,CntT,ValueT> &aoNode)
{
 ENUM_HASHDICT_OPTYPE loOpType = enum_op_ok;
 
 unsigned int luiKey = aoNode.m_tKey % m_oHashDict.m_tHashNum;
 
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpNode = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
 
 while(lpNode)
 {
  if(lpNode->m_tKey == aoNode.m_tKey)
  {
   break;
  }
  
  lpNode = lpNode->m_pNext;
 }
 
 if(lpNode)
 {
  aoNode.m_tValue = lpNode->m_tValue;
  aoNode.m_tCnt = lpNode->m_tCnt;
 }
 else
 {
  loOpType = enum_node_not_exist;
 }
 
 return loOpType;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CHashDict<KeyT,CntT,ValueT>::Adjust()
{
 unsigned int luiHashNum = m_oHashDict.m_tNodeNum % 2 ? m_oHashDict.m_tNodeNum/2 + 1:m_oHashDict.m_tNodeNum/2;
  
 STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> **lpHashTbl = new STRU_HASH_DICT_NODE<KeyT,CntT,ValueT>*[luiHashNum];
 
 delete [] m_oHashDict.m_oHashTbl.m_pHash;
 
 m_oHashDict.m_oHashTbl.m_pHash = lpHashTbl;
 m_oHashDict.m_tHashNum = luiHashNum;
 
 STRU_HASH_BLOCK<KeyT,CntT,ValueT> *lpNodeBlock = m_oHashDict.m_pFirstBlock;
 
 unsigned int luiLoopCnt = HASH_DICT_BLOCK_NUM;
 unsigned int luiKey = 0;
 while(lpNodeBlock)
 {
  if(!lpNodeBlock->m_pNext)
  {
   luiLoopCnt = HASH_DICT_BLOCK_NUM - m_oHashDict.m_uiAvailNum;
   
   STRU_HASH_DICT_NODE<KeyT,CntT,ValueT> *lpNode = lpNodeBlock->m_nHashNode;
   for(int i = 0;i<luiLoopCnt;i++)
   {
    if(lpNode[i].m_tKey)
    {
     luiKey = lpNode[i].m_tKey % luiHashNum;
    }
    else
    {
     luiKey = (luiKey + 1)%luiHashNum;
    }
    
    if(m_oHashDict.m_oHashTbl.m_pHash[luiKey])
    {
     lpNode[i].m_pNext = m_oHashDict.m_oHashTbl.m_pHash[luiKey];
     m_oHashDict.m_oHashTbl.m_pHash[luiKey] = &lpNode[i];     
    }
    else
    {
     lpNode[i].m_pNext = 0;
     m_oHashDict.m_oHashTbl.m_pHash[luiKey] = &lpNode[i];
    }
   }
  }
  
  lpNodeBlock = lpNodeBlock->m_pNext;
 }
 
 return enum_op_ok; 
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::CSearchDict<KeyT,CntT,ValueT>::CSearchDict()
{}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::CSearchDict<KeyT,CntT,ValueT>::~CSearchDict()
{}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CSearchDict<KeyT,CntT,ValueT>::Load(const char *apPath,const char *apFile)
{
 char lstrName[512];
 snprintf(lstrName,512,"%s/%s.info",apPath,apFile);
 
 FILE *lpFileInfo = fopen(lstrName,"r");
 
 unsigned int luiHashNum = 0,luiNodeNum = 0,luiCurCnt=0;
 
 if(fscanf(lpFileInfo,"hash_base=%u\nnode_num=%u\ncnt=%u\n",&luiHashNum,&luiNodeNum,&luiCurCnt) != 3)
 {
  fclose(lpFileInfo);
  return enum_op_error;
 }
 
 fclose(lpFileInfo);
 
 m_oSearchDict.m_tHashNum = luiHashNum;
 m_oSearchDict.m_tNodeNum = luiNodeNum;
 m_oSearchDict.m_ptHashSkip = new CntT[luiHashNum];
 m_oSearchDict.m_ptItemNum = new CntT[luiHashNum];
 
 FILE *lpFileData1 = 0,*lpFileData2 = 0;
 
 snprintf(lstrName,512,"%s/%s.data1",apPath,apFile);
 lpFileData1 = fopen(lstrName,"r");
 if(fread(m_oSearchDict.m_ptHashSkip,sizeof(CntT),luiHashNum,lpFileData1) != luiHashNum)
 {
  fclose(lpFileData1);
  delete [] m_oSearchDict.m_ptHashSkip;
  delete [] m_oSearchDict.m_ptItemNum;
  return enum_op_error;
 }
 
 if(fread(m_oSearchDict.m_ptItemNum,sizeof(CntT),luiHashNum,lpFileData1) != luiHashNum)
 {
  fclose(lpFileData1);
  delete [] m_oSearchDict.m_ptHashSkip;
  delete [] m_oSearchDict.m_ptItemNum;
  return enum_op_error;
 }
 
 fclose(lpFileData1);
 
 snprintf(lstrName,512,"%s/%s.data2",apPath,apFile);
 lpFileData2 = fopen(lstrName,"r");
 
 m_oSearchDict.m_pNodes = new STRU_DICT_SAVE_NODE<KeyT,ValueT>[luiNodeNum];
 if(fread(m_oSearchDict.m_pNodes,sizeof(STRU_DICT_SAVE_NODE<KeyT,ValueT>),luiNodeNum,lpFileData2) != luiNodeNum)
 {
  delete [] m_oSearchDict.m_ptHashSkip;
  delete [] m_oSearchDict.m_ptItemNum;
  delete [] m_oSearchDict.m_pNodes;
  return enum_op_error;
 }
 
 fclose(lpFileData2);
 
 return enum_op_ok;
}

template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CSearchDict<KeyT,CntT,ValueT>::Destroy()
{
 delete [] m_oSearchDict.m_ptHashSkip;
 delete [] m_oSearchDict.m_ptItemNum;
 delete [] m_oSearchDict.m_pNodes;
 
 return enum_op_error;
}
 
template<class KeyT,class CntT,class ValueT>
EA_COMMON::ENUM_HASHDICT_OPTYPE EA_COMMON::CSearchDict<KeyT,CntT,ValueT>::Find(STRU_DICT_SAVE_NODE<KeyT,ValueT> &aoNode)
{
 unsigned int luiKey = aoNode.m_tKey % m_oSearchDict.m_tHashNum;
 
 STRU_DICT_SAVE_NODE<KeyT,ValueT> *lpNode = 0;
 
 for(unsigned int i = 0;i < m_oSearchDict.m_ptItemNum[luiKey];i++)
 {
  int liIndex = m_oSearchDict.m_ptHashSkip[luiKey] + i;
  lpNode = &m_oSearchDict.m_pNodes[liIndex];
  
  if(lpNode->m_tKey == aoNode.m_tKey)
  {
   aoNode.m_tValue = lpNode->m_tValue;
   return enum_op_ok;
  }
 }
 
 return enum_op_error;
}

 

chenbingchenbing
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python Json序列化与反序列化的示例
01-21
不同的编程语言有不同的数据类型; 比如说: Python的数据类型有(dict、list、string、int、float、long、bool、...Ruby的数据类型(Number、String、Ranges、Symbols、true、false、Array、Hash) … 他们的共同特点是，
分析线性表、二叉平衡树和哈希表存储数据时各自的优劣
WilburYao的博客
04-25 1775
链接：https://www.nowcoder.com/questionTerminal/b67ebdf7e1a84f37a9b1ed578525f625 线性表，插入的时间复杂度为O(1)，但是因内部无法保证有序，所以查找需要O(Length)的时间复杂度，而删除则取决于所用实现是链表还是数组，链表为O(1)，数组为O(Length)。虽然时间复杂度看起来比较糟糕，但是其时间常数相对后两者...
关于 Java 对象序列化您不知道的 5 件事
GarfieldEr007的专栏
03-31 1172
数年前，当和一个软件团队一起用 Java 语言编写一个应用程序时，我体会到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处。 关于本系列 您觉得自己懂 Java 编程？事实上，大多数程序员对于 Java 平台都是浅尝则止，只学习了足以完成手头上任务的知识而已。在本 系列 中，Ted Neward 深入挖掘 Java 平台的核心功能，揭示一些鲜为人知的事实，帮助
区块链常用序列化分析
u011387274的博客
06-12 1797
parity开源解析 parity-scale-codec 用于Parity Substrate框架中的类型的SCALE（Simple Concatenated Aggregate Little-Endian）数据格式的Rust实现。 SCALE是一种轻量级格式，允许编码（和解码），使其非常适合资源受限的执行环境，如区块链运行时和低功耗，低内存设备。 它是一种极轻量级的编码格式，专为资源受限的执行上下文（如Substrate运行时）中的高性能，无副本编码和数据解码而设计。它 不以任何方式自我描述，并假设..
序列化--关于 Java 对象序列化您不知道的 5 件事
szzt_lingpeng的专栏
12-31 405
转摘自：http://www.ibm.com/developerworks/cn/java/j-5things1/ 序列化的数据是安全的？不见得吧。 Java 对象序列化（Java Object Serialization）在 Java 编程中是如此基本，以致很容易让人想当然。但是，和 Java 平台的很多方面一样，只要肯深入挖掘，序列化总能给予回报。在这个新系列的第一
JSON序列化Redis读取出错问题解决方案
10-14
主要介绍了JSON序列化Redis读取出错问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JSON与js对象序列化实例详解
12-01
本文实例讲述了JSON与js对象序列化。分享给大家供大家参考，具体如下： JavaScript对象表示法（JavaScript Object Notation，简称JSON）是一种轻量级的数据交换格式，它基于js字面量表示法，是js的一个子集。虽然是...
hash极化
01-08
hash ...Hash极化，是指流量经过2次或2次以上Hash后出现的负载分担不均匀的现象。常见于跨设备的多次Hash场景，即第一级进行ECMP Hash，第二级再进行ECMP或者Eth-Trunk Hash。在同一设备上，若存在EC
Hash_MFC.rar_MFC中hash功能_可视化
09-24
哈希表的实现，mfc可视化编程实现，学习数据结构
infrared-remote-candroid studiodemo
05-05
android studio下载
【新质生产力】新质生产力赋能智能制造数字化解决方案.pptx
05-05
【新质生产力】新质生产力赋能智能制造数字化解决方案.pptx
基于matlab实现的用于应用布格重力异常数据反演地下异常密度体.rar
05-05
基于matlab实现的用于应用布格重力异常数据反演地下异常密度体.rar
node-v8.10.0-linux-x64.tar.xz
05-05
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于Yolov5目标检测和deepsort目标跟踪无人机跟踪.zip
05-05
无人机最强算法源码，易于部署和学习交流使用
数据库课程设计实战.zip
05-05
数据库课程设计后端 使用Springboot + Mybatis + Redis + Maven 数据库课程设计实战.zip，使用到了所有的相关SQL 的操作，如增删改查等，让你可以在一个项目里面，锻炼到所有的数据库相关的知识。项目亲测可以运行，里面含有运行相关的文档，不会的可以丝我请求帮助。 数据库课程设计后端 使用Springboot + Mybatis + Redis + Maven 具体的表和相关的数据如下： 用户（电话号码，密码，身份证号，邮箱，真实姓名，用户类型，性别，地址） 乘客（用户电话号码，乘客身份证号，乘客真实姓名，乘客电话号码，乘客类型，地址） 列车信息（列车编号，车次，列车类型，列车车厢数，列车始发站，列车终点站，列车开车时间，列车到达时间，列车到达日期，列车运行时间，列车状态） 列车座位信息（列车编号，车厢号，座位类型，座位数） 列车经停信息（列车编号，车次，车站编号，车站名，到达时间，总运行时间，开车时间） 订单信息（订单编号，用户电话号码，乘客身份证号码，列车编号，出发站编号，到达站编号，车厢号，座位编号，订单创建时间，订单状态，开车时间）
咨询的分析方法gl.ppt
05-05
咨询的分析方法gl.ppt
node-v10.14.0-linux-ppc64le.tar.xz
最新发布
05-05
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
序列化对象中的hash map，hash set，hash table等集合可以包含对象自身的引用
06-06
在Java中，对象的序列化是将对象转换为字节流的过程，可以将序列化后的对象进行传输或存储。当我们序列化一个对象时，如果这个对象中包含了其他对象的引用，那么这些被引用的对象也会被序列化。 对于HashMap、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值