哈希表除去重复数据

最新推荐文章于 2023-12-13 19:58:09 发布
最新推荐文章于 2023-12-13 19:58:09 发布
阅读量786 收藏
点赞数
分类专栏： 哈希表除去重复数据 文章标签：  哈希表除去重复数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37777700/article/details/84630098
版权

 

memcpy((char*)&E, (char*)&tag, sizeof(HashElem_t));
Hash_Save(&g_Hash, &E, &Addr, &c);

 

#include "main.h"

#if C_USE_TAG_HASH==1

//==============================================================================
// Variables

HashTable_t g_Hash;
/*==============================================================================
* Function:
* Input para1: Void
* Return:      Void
==============================================================================*/
Status_t Hash_Initial(HashTable_t *pHash)
{
  int i,m;
  
  m = C_HASH_TABLE_SIZE;
  pHash->Cnt = 0;
  pHash->MaxCnt = m;
  
#if C_HASH_MALLOC
  pHash->pElem = (HashElem_t*)malloc(m*sizeof(HashElem_t)); // 动态分配数组
  //void *malloc(size_t size);
#endif
  
  //    memset((char*)&pHash, 0, sizeof(HashTable_t));
  
  for(i=0;i<m;i++)
  {
    //        memset((char*)&pHash->pElem[i].Value, 0, sizeof(HashValue_t));
    memset((char*)&pHash->pElem[i], 0, sizeof(HashElem_t));
    HashKeySource(pHash->pElem[i]) = C_HASH_KEY_NULL;
    //		pHash->pElem[i].Key = C_HASH_KEY_NULL;
    
    pHash->AddrFifo.Addr[i] = C_HASH_ADDR_INVALID;
  }
  return(C_HASH_STATUS_OK);
}

/*==============================================================================
* Function:
* Input para1: Void
* Return:      Void
==============================================================================*/
uint16_t Hash_Cnt(HashTable_t *pHash)
{
  return(pHash->Cnt);
}
/*==============================================================================
* Function:
* Input para1:  pHash         哈希表地址
*               K             关键字
* Output para1: pAddr         存储地址
*               c             冲突次数
* Return:
// 在开放定址哈希表pHash中查找关键码为K的元素,若查找成功,以pAddr指示待查数据
// 元素在表中位置,并返回SUCCESS;否则,以pAddr指示插入位置,并返回UNSUCCESS
// c用以计冲突次数，其初值置零，供建表插入时参考。算法9.17
==============================================================================*/
Status_t Hash_Find(HashTable_t *pHash, HashKey_t K, uint16_t *pAddr, uint16_t *c)
{
  int m;
  
  m = C_HASH_TABLE_SIZE;
  *c = 0;
  
  *pAddr = Hash(K); // 求得哈希地址
  
  //    if(pHash->pElem[*pAddr].Key == K)
  if(HashKeySource(pHash->pElem[*pAddr]) == K)
  {
    return(C_HASH_STATUS_OK);
  }
  while(1)
  {
    (*c)++;
    if((*c) >= m)
    {
      return(C_HASH_STATUS_ERROR);  // 溢出
    }
    //        *pAddr = (*pAddr+1) % m;      /* 开放定址法的线性探测 */
    *pAddr = Collision(*pAddr, 1);  // 求得下一探查地址
    //Collision(pAddr, *c);         // 求得下一探查地址
    
    if(HashKeySource(pHash->pElem[*pAddr]) == K)
    {
      break;
    }
    //        if((pHash->pElem[*pAddr].Key == C_HASH_KEY_NULL)
    //        {
    //            return(C_HASH_STATUS_ERROR); //
    //        }
  }
  //    memcpy((char*)pElem, (char*)&pHash->pElem[*pAddr], sizeof(HashElem_t));
  
  return(C_HASH_STATUS_OK);
}

/*==============================================================================
* Function:
* Input para1:  pHash         哈希表地址
*               pNewElem      新元素
* Output para1: pAddr         存储地址
*               c             冲突次数
* Return:
==============================================================================*/
Status_t Hash_Insert(HashTable_t *pHash, HashElem_t *pNewElem, uint16_t *pAddr, uint16_t *c)
{
  Status_t ret;
  
  if(pHash->Cnt >= pHash->MaxCnt)
  {
    return(C_HASH_STATUS_ERROR);  // 满
  }
  ret = Hash_Find(&g_Hash, C_HASH_KEY_NULL, pAddr, c); // 找个空位
  
  if(C_HASH_STATUS_OK != ret)
  {
    return(C_HASH_STATUS_ERROR);
  }
  memcpy((char*)&pHash->pElem[*pAddr], (char*)pNewElem, sizeof(HashElem_t)); // 保存
  pHash->Cnt++;
  
  return(C_HASH_STATUS_OK);
}
/*==============================================================================
* Function:
* Input para1:  pHash         哈希表地址
*               pNewElem      新元素
* Output para1: pAddr         存储地址
*               c             冲突次数
* Return:
==============================================================================*/
//Status_t Hash_Insert_(HashTable_t *pHash, HashElem_t *pElem, uint16_t *pAddr, uint16_t *c)
//{
//    int m;
//
//    if(pHash->Cnt >= pHash->MaxCnt)
//    {
//        return(C_HASH_STATUS_ERROR);  // 满
//    }
//    m = C_HASH_TABLE_SIZE;
//    *c = 0;
//
    *pAddr = Hash(pElem->Key);    // 求得哈希地址
//    *pAddr = Hash(HashKeySource((*pElem)));    // 求得哈希地址
//
//
//    while(1)
//    {
//        if(HashKeySource(pHash->pElem[*pAddr]) != C_HASH_KEY_NULL)
//        { /* 如果不为空，则冲突 */
//            (*c)++;
//            if((*c)<m)
//            {
//                *pAddr = (*pAddr+1) % m; /* 开放定址法的线性探测 */
//                // Collision(pAddr, *c); // 求得下一探查地址p
//            }
//            else
//            {
//                return(C_HASH_STATUS_ERROR);  // 溢出
//            }
//        }
//        else
//        {   /* 直到有空位后插入关键字 */
//            //pHash->pElem[*pAddr].Key = pElem->Key;
//            memcpy((char*)&pHash->pElem[*pAddr], (char*)pElem, sizeof(HashElem_t));
            pHash->pElem[*pAddr].HashPos = *pAddr;
//            pHash->Cnt++;
//            break;
//        }
//    }
//    return(C_HASH_STATUS_OK);
//}
/*==============================================================================
* Function:
* Input para1:  pHash         哈希表地址
*               pNewElem      新元素
* Output para1: pAddr         存储地址
*               c             冲突次数
* Return:
==============================================================================*/
Status_t Hash_Save(HashTable_t *pHash, HashElem_t *pNewElem, uint16_t *pAddr, uint16_t *c)
{
  int m;
  //  bool Hash_Repeat= false;//20170629 Seven 区别是否有重复数据
  m = C_HASH_TABLE_SIZE;
  *c = 0;
  //    *pAddr = Hash(pNewElem->Key); // 求得哈希地址
  *pAddr = Hash(HashKeySource((*pNewElem))); // 求得哈希地址
  
  while(1)
  {
    if(HashKeySource(pHash->pElem[*pAddr]) == HashKeySource((*pNewElem)))
    {// 找到已有位置
      if(pHash->pElem[*pAddr].UplodeCnt>=0)
      {
        (*pNewElem).UplodeCnt = pHash->pElem[*pAddr].UplodeCnt;//超时时间未到，不更新超时
      }
      else
      {
        
      }
      //  Hash_Repeat = false;
      //            // 补充测试
      //            if(0x7F != pHash->pElem[*pAddr].Bat)
      //            {
      //                return(C_HASH_STATUS_ERROR);     // 溢出
      //            }
      
      break;
    }
    if(HashKeySource(pHash->pElem[*pAddr]) == C_HASH_KEY_NULL)
    {// 找到空位置
      pHash->Cnt++;
      
      Hash_AddrFifo_In(&g_Hash, *pAddr); //
      
      break;
    }
    (*c)++;
    if((*c) >= m)
    {
      return(C_HASH_STATUS_ERROR);     // 溢出
    }
    *pAddr = Collision(*pAddr, 1);  // 求得下一探查地址  /* 开放定址法的线性探测 */
  }
  
  memcpy((char*)&pHash->pElem[*pAddr],
         (char*)pNewElem,
         sizeof(HashElem_t)); // 保存
  
  return(C_HASH_STATUS_OK);
  
  // 方法2
  //    ret = Hash_Find(&g_Hash, pNewElem->Key, &Addr, &c);
  //    if(C_HASH_STATUS_OK != ret)
  //    {
  //        return(C_HASH_STATUS_ERROR);
  //    }
  //    memcpy((char*)&pHash->pElem[Addr], (char*)pNewElem, sizeof(HashElem_t));
  //
  //	return(C_HASH_STATUS_OK);
}
/*==============================================================================
* Function:     按关键字查找并读出
* Input para1:  pHash         哈希表地址
*               K             关键字
* Output para1: pElem         元素地址
*               pAddr         元素存储地址
*               c             冲突次数
* Return:
==============================================================================*/
Status_t Hash_Read(HashTable_t *pHash, HashKey_t K, HashElem_t *pElem, uint16_t *pAddr, uint16_t *c)
{
  Status_t ret;
  
  ret = Hash_Find(&g_Hash, K, pAddr, c);
  if(C_HASH_STATUS_OK != ret)
  {
    return(C_HASH_STATUS_ERROR);
  }
  memcpy((char*)pElem, (char*)&pHash->pElem[*pAddr], sizeof(HashElem_t));
  
  return(C_HASH_STATUS_OK);
}
/*==============================================================================
* Function:     按关键字删除
* Input para1:  pHash         哈希表地址
*               K             关键字
* Output para1: pAddr         元素存储地址
*               c             冲突次数
* Return:
==============================================================================*/
Status_t Hash_Remove(HashTable_t *pHash, HashKey_t K, uint16_t *pAddr, uint16_t *c)
{
  Status_t ret;
  
  //    HashElem_t EmptyElem;
  //    EmptyElem.Key = C_HASH_KEY_NULL;
  
  ret = Hash_Find(&g_Hash, K, pAddr, c);
  if(C_HASH_STATUS_OK != ret)
  {
    return(C_HASH_STATUS_ERROR);
  }
  if(*pAddr >= C_HASH_TABLE_SIZE)
  {
    return(C_HASH_STATUS_ERROR);
  }
  //    memcpy((char*)&pHash->pElem[*pAddr], (char*)EmptyElem, sizeof(HashElem_t));
  HashKeySource((pHash->pElem[*pAddr])) = C_HASH_KEY_NULL;
  
  return(C_HASH_STATUS_OK);
}
/*==============================================================================
* Function:     直接删除
* Input para1:  pHash         哈希表地址
*               pAddr         元素存储地址
* Return:
==============================================================================*/
Status_t Hash_Delete(HashTable_t *pHash, uint16_t *pAddr)
{
  //    HashElem_t EmptyElem;
  //    EmptyElem.Key = C_HASH_KEY_NULL;
  
  if(*pAddr >= C_HASH_TABLE_SIZE)
  {
    return(C_HASH_STATUS_ERROR);
  }
  if(C_HASH_KEY_NULL != HashKeySource(pHash->pElem[*pAddr]))
  {
    if(pHash->Cnt > 0)
    {
      pHash->Cnt--;
    }
    
  }
  //    memcpy((char*)&pHash->pElem[*pAddr], (char*)EmptyElem, sizeof(HashElem_t));
  HashKeySource((pHash->pElem[*pAddr])) = C_HASH_KEY_NULL;
  
  return(C_HASH_STATUS_OK);
}

/*==============================================================================
* Function:
* Input para1: Void
* Return:      Void
==============================================================================*/
int Hash_AddrFifo_In(HashTable_t *pHash, uint16_t NewAddr)
{
  if(pHash->AddrFifo.WriteIndex>=C_HASH_ADDR_FIFO_SIZE)
  {
    return(-1);
  }
  //-------------------------------------------
  pHash->AddrFifo.Addr[pHash->AddrFifo.WriteIndex] = NewAddr;
  
  //-------------------------------------------
  pHash->AddrFifo.WriteIndex++;
  if(pHash->AddrFifo.WriteIndex>=C_HASH_ADDR_FIFO_SIZE)
  {
    pHash->AddrFifo.WriteIndex = 0;
  }
  //-------------------------------------------
  pHash->AddrFifo.Num++;
  if(pHash->AddrFifo.Num>C_HASH_ADDR_FIFO_SIZE)
  {
    pHash->AddrFifo.Num = C_HASH_ADDR_FIFO_SIZE;
  }
  //-------------------------------------------
  return(g_TagFifo.WriteIndex);
  
  
}


//==============================================================================
//==============================================================================
int Hash_AddrFifo_Out(HashTable_t *pHash, uint16_t *pNewAddr)
{
  //    if(g_TagFifo.ReadIndex==g_TagFifo.WriteIndex)
  //    {
  //        return(-1);
  //    }
  uint16_t index, Addr;
  uint16_t i;//Seven
  uint16_t z = 0;
  if(pHash->AddrFifo.ReadIndex >= C_HASH_ADDR_FIFO_SIZE)
  {
    pHash->AddrFifo.ReadIndex = 0;
    return(-1);
  }
  if(g_Hash.Cnt>0)
  {
    for(i=0;i<C_HASH_ADDR_INVALID;i++)
    {
      Addr = pHash->AddrFifo.Addr[pHash->AddrFifo.ReadIndex];
      if(pHash->pElem[Addr].Flag)
      {
        z++;
        if(z>g_Hash.Cnt)
        {
          break;
        }      
        if(pHash->pElem[Addr].UplodeCnt==0)
        {
          break;
        }   
      }
      pHash->AddrFifo.ReadIndex++;
      if(pHash->AddrFifo.ReadIndex>=C_HASH_ADDR_FIFO_SIZE)
      {
        pHash->AddrFifo.ReadIndex = 0;
      }
    }
  }
  else
  {
    Addr = pHash->AddrFifo.Addr[pHash->AddrFifo.ReadIndex]; 
  }
  
  
  if(C_HASH_ADDR_INVALID <= Addr)
  {
    return(-1);
  }
  
  //-------------------------------------------
  *pNewAddr = Addr;
  //-------------------------------------------
  pHash->AddrFifo.Addr[pHash->AddrFifo.ReadIndex] = C_HASH_ADDR_INVALID;
  
  index = pHash->AddrFifo.ReadIndex;
  
  //-------------------------------------------
  pHash->AddrFifo.ReadIndex++;
  if(pHash->AddrFifo.ReadIndex>=C_HASH_ADDR_FIFO_SIZE)
  {
    pHash->AddrFifo.ReadIndex = 0;
  }
  //-------------------------------------------
  if(pHash->AddrFifo.Num!=0)
  {
    pHash->AddrFifo.Num--;
    
    if(pHash->AddrFifo.Num==0)
    {
      if(pHash->AddrFifo.ReadIndex==g_TagFifo.WriteIndex)
      {
        pHash->AddrFifo.ReadIndex = 0;
        pHash->AddrFifo.WriteIndex = 0;
      }
    }
  }
  //-------------------------------------------
  return(index);
}


//#if C_USE_UPLOAD_LIMIT
//int Hash_AddrFifo_Out_One(HashTable_t *pHash, uint16_t *pNewAddr)
//{
    if(g_TagFifo.ReadIndex==g_TagFifo.WriteIndex)
    {
        return(-1);
    }
//    uint16_t index, Addr;
//
//    if(pHash->AddrFifo.ReadIndex >= C_HASH_ADDR_FIFO_SIZE)
//    {
//        pHash->AddrFifo.ReadIndex = 0;
//    }
//    
//    Addr = pHash->AddrFifo.Addr[pHash->AddrFifo.ReadIndex];
//
//    if(C_HASH_ADDR_INVALID <= Addr)
//    {
//        return(-1);
//    }
//    //-------------------------------------------
//    *pNewAddr = Addr;
//
//    //-------------------------------------------
//    pHash->AddrFifo.Addr[pHash->AddrFifo.ReadIndex] = C_HASH_ADDR_INVALID;
//
//    index = pHash->AddrFifo.ReadIndex;
//
//    //-------------------------------------------
//    pHash->AddrFifo.ReadIndex++;
//    if(pHash->AddrFifo.ReadIndex>=C_HASH_ADDR_FIFO_SIZE)
//    {
//        pHash->AddrFifo.ReadIndex = 0;
//    }
//    //-------------------------------------------
//  //  if(pHash->pElem[Addr].UplodeCnt==0)
//  //  {
//    if(pHash->AddrFifo.Num!=0)
//    {
//        pHash->AddrFifo.Num--;
//
//        if(pHash->AddrFifo.Num==0)
//        {
//            if(pHash->AddrFifo.ReadIndex==g_TagFifo.WriteIndex)
//            {
//                pHash->AddrFifo.ReadIndex = 0;
//                pHash->AddrFifo.WriteIndex = 0;
//            }
//        }
//    }
   }
//    //-------------------------------------------
//    return(index);
//}
//#endif
//

/*==============================================================================
* Function:
* Input para1: Void
* Return:      Void
==============================================================================*/
void Hash_Test(void)
{
#if 0
  Status_t    ret;
  HashElem_t  E;
  uint16_t    Addr;
  uint16_t    c;
  HashKey_t   K;
  
  ret =  Hash_Initial(&g_Hash);
  
  E.Value.TagData.ReadTime = 43;
  E.Value.TagData.Bat = 0;
  E.Value.TagData.Rssi = 55;
  E.Value.TagData.Flag = 0;
  
  E.Key = 120;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 4120;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 450;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 670;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 4;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 50;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  E.Key = 170;
  ret =  Hash_Insert(&g_Hash, &E, &Addr, &c);
  
  K = 450;
  ret =  Hash_Find(&g_Hash, K, &Addr, &c);
  
  K = 4;
  ret =  Hash_Find(&g_Hash, K, &Addr, &c);
  
  K = 7;
  ret =  Hash_Find(&g_Hash, K, &Addr, &c);
  
  if(ret)
  {
    return;
  }
#endif
}

void Tag_Hash_flash(HashTable_t *pHash)
{
  if(g_Config.iLimitUPloadFlag)
  {
    uint16_t i;
    F_LED2_ON();
    if(pHash->Cnt<=0)
    {
      return;
    }
    for(i=0;i<C_HASH_TABLE_SIZE;i++)
    {
      if(pHash->pElem[pHash->AddrFifo.Addr[i]].Flag)
      {
        if(pHash->pElem[pHash->AddrFifo.Addr[i]].UplodeCnt>0)
        {
          pHash->pElem[pHash->AddrFifo.Addr[i]].UplodeCnt--;
        }
        //    else
        //    {
        //      pHash->pElem[pHash->AddrFifo.Addr[i]].UplodeCnt=5;
        //    }
      }
    }
    F_LED2_OFF();
  }
  
#if 0//test  
  uint8_t data,data1;
  if(g_Hash.Cnt>0)
  {//刷新超时  
    data = g_Hash.pElem[g_Hash.AddrFifo.Addr[0]].UplodeCnt;   
    data1 = data;
    if(data1==0)
      data1 = 5;
    else
      data1--;
    g_Hash.pElem[g_Hash.AddrFifo.Addr[0]].UplodeCnt = data1; 
  }
#endif
}

#endif

 

 

 

 

 

天使画笔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言用hash方式数组去重,利用set实现去重
weixin_35387118的博客
05-22 825
最近读了一些有关于ES6的文章，觉得真是一个超级大的进步，就是不知道兼容性怎么样，鉴于我还在初学，先写个小例子练手，顺便时刻提醒自己要坚持学下去。未来的趋势肯定是替代es5没跑了。var arr=[1,2,1,3,2,4,5,1,3];var setArr=new Set(arr);var newArr=[];setArr.forEach(function(e){newArr.push(e);})...
【学习记录】怎么用哈希算法检查重复值
swiftwwj的博客
02-24 1367
例题：检验数独是否成立 核心代码 public static class RowColumnObject { int row; int col; RowColumnObject(int row, int column) { this.row = row; this.col = column; ...
[哈希表标记思想]删除重复元素保留1个
StudyingPanda的博客
12-13 355
输入n 个整型数，把其中重复出现的元素删去（如出现三个5，则只保留第一次出现的5，删去后两个5），将剩余的元素顺次输出。整数个数 n 不大于300。
使用哈希表（HashSet）删除链表中的重复元素
二哈
11-29 3220
1. 删除链表中的重复元素 我们可以使用两种方法去解决： ① 一种是利用哈希表（HashSet），哈希表特别适合于判断集合中是否有重复的元素 ② 第二种方法是直接使用遍历链表，使用两层for循环去遍历再来找出重复的元素，下面使用哈希表来寻找重复的元素 2. 首先我们要解决几个问题 ①如何利用数组来生成一个链表，这里我们可以构建一个哑元（空的节点）来进行数组中每个元素作为节点的生成 ②...
数组去重C语言怎么写，需要完整的代码
weixin_35756130的博客
02-13 727
在 C 语言中可以使用以下方法来去除数组中的重复元素： 可以将数组中的所有元素放到一个哈希表中，然后再遍历哈希表将不重复的元素添加到另一个数组中。 也可以对数组进行排序，然后在遍历数组时判断当前元素是否与前一个元素相同，如果不同则将其添加到另一个数组中。 以下是使用第二种方法的代码示例： ``` #include <stdio.h> #include <stdlib.h&...
LeetCode 82. 删除排序链表中的重复元素 II 哈希表+链表
weixin_44863500的博客
03-02 72
链表，哈希表
易语言除去重复数据
07-23
"易语言除去重复数据"这个主题就是关于如何使用易语言这一国产编程工具来处理数据集合中的重复项。易语言，全称“易语言·飞扬”，是一种简单易学、功能强大的编程语言，它的设计目标是降低广大用户的编程门槛，使不...
C++数据结构哈希表
04-01
哈希表，又称散列表，是数据结构中一种高效存储和检索数据的结构。它通过一个函数，通常称为哈希函数，将关键字映射到数组的特定位置，从而实现快速访问。在C++中，虽然标准库并没有直接提供哈希表的实现，但我们...
c语言面试题之哈希表重复N次的元素.zip
最新发布
03-29
总结来说，本题考察的是利用哈希表解决查找重复元素的问题，这涉及到对数据结构的理解和基本的哈希函数设计。在C语言中，虽然没有内置的哈希表支持，但我们可以通过自定义结构来实现。理解哈希表的工作原理以及如何...
chazhao.rar_哈希表_哈希表 查找
09-21
哈希表是一种高效的数据结构，它通过特定的函数——哈希函数，将数据映射到一个固定大小的数组中，以此实现快速的插入、删除和查找操作。在本压缩包文件"chazhao.rar"中，我们主要探讨的是哈希表在查找操作中的应用...
haxibiao.rar_哈希表电话
09-22
哈希表，也被称为散列表，是一种数据结构，它提供了快速的数据存储和检索能力，通常用于实现高效查找、插入和删除操作。在本场景中，"哈希表电话"指的是用哈希表来管理电话号码及其相关的联系人信息，使得在电话簿中...
C# 使用Hashtable 判断重复值
yinsings的博客
07-13 972
给定一张表格，判断其中哪些字段下的数据有重复值 Hashtable ht = new Hashtable(); for (int u = 0; u < uniquesz.Length; u++) { for (int i = 0; i < rows.Count; i++) //循环获取该字段下的所有数据 { Hashtable row1 = (Hashtable)rows[i]; ht.Add(i, row1[uniquesz[u]]);
哈希算法实现在海量数据里提取重复值
SunStone的小屋
07-22 1586
那天给兰州石化矿区服务事业部的领导处理Excel表格！发现在35400行数据中提取重复值时，竟然耗时3小时，当时使用的是普通算法进行查找的！严重的时间消耗让我不得不修改提取重复值的程序了！之后第二天，我详细的研究了一下。突然，想起在大学时，主修计算机科学与技术时的数据结构算法-哈
hash 值重复_基于最小哈希的重复数据清洗方法
weixin_39713814的博客
11-30 896
大数据时代，数据的处理和应用受到了极大关注，重复数据清洗作为数据预处理的一部分，影响着数据预处理的效率和结果。主要针对重复数据进行处理，现有的方法主要采用了datacleaner的基础模块找出重复数据，由于需要对每个属性单独进行编码，相对繁琐。我们创新性的将数据转换为一段文字，利用最小哈希(minhash)编码方式对该段文字进行统一的编码，然后计算Jaccard相似度，从而找出重复数据。...
数组中重复的数字(哈希表，换位索引)
weixin_61898526的博客
04-27 325
找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例 1： 输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3 解题思路1：哈希表 1.创建一个哈希表 2.遍历nums数组中每个元素 如果该元素在哈希表中的值为true 则...
原地哈希解决查找数组缺失重复问题
Roxannekkk的博客
08-05 260
引言 有这样一类题型，他需要你在给定的数组中找到缺失的值或者重复的值，当然你可以利用HashSet来做，遍历数组，存储每个元素，然后根据题目要求，即可以得到正确的解，但这样做也有一个问题，导致其空间复杂度为O(n)O(n)O(n)，能否有一种方法，使得其既能完成题目要求，同时只用常数级别的空间呢，确实有，就是原地哈希 思想 原地哈希的思想可以理解为：把原始的数组当做哈希表来使用，我们自己编写哈希函数来存储值，根据题目的不同，所设置的哈希函数也不同。 下面我们直接以例题分析，从例题中明白其中思想。 实例
数据结构与算法_大数据查重问题解决方法-哈希表
weixin_43916755的博客
10-10 407
用哈希表解决大数据查重问题
用python实现通过哈希算法检测图片重复_【5分钟实例】去除大量图片中重复的图片...
weixin_30563851的博客
02-04 2104
需求假设：你的老板给你上万张候选人的证件照，但是由于某些原因，一部分人的照片有不止一张(重复了)，让你把重复出现的照片删掉，下班之前整理好发给他。你一看表距离下班只剩5分钟了，加班是不可能加班的。这时候你灵光一现，想起了python有图像处理模块拿起键盘打开你最爱的IDE二话不说首先import以下必定要用到的库import cv2import numpy as npimport os别...
STL常用操作：unordered_set
zhuikefeng的博客
03-08 9768
1.初始化 unordered_set<int> set1; //创建空set unordered_set<int> set2(set1); //拷贝构造 unordered_set<int> set3(set1.begin(), set1.end()); //迭代器构造 unordered_set<int> set4(arr,arr...
哈希表同一个位置重复插入数据
05-23
在哈希表中，如果插的数据与已有的数据的哈希值相同，那么它们会被存储在哈希表的同一个位置上，这就是所谓的哈希冲突。当发生哈希冲突时，通常有两种解决方案： 1. 链式解决法：在哈希表的每个位置上维护一个链表，将哈希值相同的元素存储在同一个链表中。 2. 开放地址解决法：当发生哈希冲突时，通过一定的算法（如线性探测、二次探测等）在哈希表中查找下一个可用的位置进行插入。 无论采用哪种解决方案，重复插入数据都不会导致数据丢失，只会增加哈希表中对应位置的链表或者探测次数。但是需要注意的是，如果哈希表的负载因子过高，即哈希表中元素数量过多，那么哈希冲突的概率会增加，导致哈希表的性能下降。因此，需要根据实际情况合理设置哈希表的容量和负载因子阈值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值