一种一致性HASH算法的实现方法，附核心代码

最新推荐文章于 2020-06-15 08:21:46 发布
最新推荐文章于 2020-06-15 08:21:46 发布
阅读量905 收藏
点赞数
分类专栏： 常用算法 nosql 文章标签： 一致性HASH 算法 hash 存储 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Searcher_Recommeder/article/details/46698809
版权

一致性HASH算法

    一致性HASH算法的原理，还有不带虚拟结点的一致性HASH算法就不说了，直接谈一下带虚拟结点的一致性HASH算法，主要从实现的角度谈一下。

整个过程包括初始化环形数组，添加结点，删除结点，查找结点等等。

先看存储结构：

class ConsistentHash

{

 

     enum STATUS{

         EMPTY=0，//初始化

         REAL,//虚拟结点

         EXT //虚拟结点顺时针方向扩展出的结点

     };

     struct Node

     {

         string   m_nodeName;//虚拟结点名称

         uint64_t m_hashKey;//虚拟结点对应的hash值

         STATUS m_valid;   //虚拟结点的状态

     };

     public:

         ConsistentHash(uint16_t  count);

         ~ConsistentHash(){

         };

 

         void printConfigInfo();

        bool removeNode(string node);

         bool  addNode(vector<string> vnodes,string node);

        string findNode(const string &key);

 

        void releaseExtNodes(Node &node,string  &vnodeName,size_t vCount);

        void printcircle();

     public:

         bool init();

 

         uint64_t hash(const string &str,uint64_t &crckey);

     private:

         Node *m_vNode;

         /*虚拟结点到实际结点*/

         unordered_map<uint64_t,string> m_v2eNode;

         /*实际结点到虚拟节点位置*/

         /*实际结点名称，虚拟节点名称，虚拟节点在环上的位置 */

         unordered_map<string,unordered_map<string,vector<size_t>  > > m_node2v;

         uint16_t m_maxCount;

};

整个结构没有复杂的数据结构，考虑到一致性HASH的应用场景，比如用到缓存代理之类的，这种应用很少会有用到添加、删除结点的情况，相反，更多的是每次访问都要做查询操作，查询操作远远多余修改操作。什么数据结构的查询效率最好呢，当然是HASH，也不是什么XX树之类的。

1，         Init

（1）初始化m_vNode，

（2）将所有的M虚拟结点做HASH映射到m_vNode。

首次映射的虚拟结点m_valid是REAL

存储虚拟结点的HASH值与实际结点的对应关系，对应关系有多种算法，这里应用的是简单的也是最均衡的顺序对应算法，比如有10个虚拟结点，2个实际结点，第1,3,5,7,9虚拟结点就对应第1个实际结点，第2，4，6，8，0虚拟结点就对应第2个实际结点，

虚拟结点到实际结点的映射关系存储在m_v2eNode

（3）所有的虚拟结点顺时针扩展势力范围直到遇到下一个虚拟结点。

扩展的虚拟结点m_valid是EXT，其它都一样。

    （4）记录第个实际结点对应那些虚拟结点，每个虚拟结点又在m_vNode中什么位置，主要是做增加和删除的时候会用到。存储数据在m_node2v

2，         查询

(1)用户输入key,转为一个HASH值，做为目的结点在m_vNode中的下标，从目的结点中取出hash值，查询m_vNode，即可得到实际结点，时间复杂度仅为o（1）。

3，         添加结点

(1) 输入为实际结点的名称，和其对应的一系列的虚拟结点名称。

(2) 映射虚拟结点到m_vNode。

映射的位置如果刚好有一个结点,并且m_valid是REAL，则要顺时针顺延到一个状态为EXT的结点，记录为A，主要是避免与现存结点冲突。

找到在m_vNode的位置后，给其赋值，更新m_v2eNode，

从m_vNode当前位置开始顺时针扩展势力范围，直到遇到一个状态为REAL的结点，记录为B，将A,B之关的位置从A对应的位置信息中移除，加入到新结点虚拟结点对应的位置信息中。

4，         删除结点

(1) 取出实际结点与虚拟结点及其位置的对应关系。

(2) 在虚拟结点的位置向量中找到最左偶的结点，左移一个位置即时该结点的逆向第一个虚拟结点，让其扩展势力范围到该虚拟结点，偶发现和原理不一样，无所谓，好懂好用就行。

(3) 删除该结点的势力范围数据。

 5，附源码

   经过简单功能测试，离实际应用还有距离。

    

/*************************************************************************
    > File Name: consistenthash.cpp
    > Author:zhangtx
    > Mail: 18510665908@163.com
    > Created Time: 2015年06月27日 星期六 14时32分42秒
 ************************************************************************/
#include<iostream>
#include<stdint.h>
#include <boost/unordered_map.hpp>
#include "StringAlgorithms.h"
#include "Common.h"
using namespace std;
using namespace boost;
string vnode="VNODE1:VNODE2:VNODE3:VNODE4:VNODE5:VNODE6:VNODE7:VNODE8:VNODE9:VNODE10:VNODE11:VNODE12:VNODE13:VNODE14:VNODE15";
string node="172.16.73.68:172.16.73.76:172.16.73.194";

const uint16_t NODE_COUNT=1024;


/*create node count virtual node*/
class ConsistentHash
{

    enum STATUS{
        EMPTY=0,
        REAL,
        EXT
    };
    struct Node
    {
        string   m_nodeName;
        uint64_t m_hashKey;
        STATUS m_valid;
    };
    public:
    ConsistentHash(uint16_t count);
    ~ConsistentHash(){
    };

    void printConfigInfo();
    bool removeNode(string node);
    bool addNode(vector<string> vnodes,string node);
    string findNode(const string &key);

    void releaseExtNodes(Node &node,string &vnodeName,size_t vCount);
    void printcircle();
    public:
        bool init();
 
        uint64_t hash(const string &str,uint64_t &crckey);
    private:
        Node *m_vNode;
        /*虚拟结点到实际结点*/
        unordered_map<uint64_t,string> m_v2eNode;
        /*实际结点到虚拟节点位置*/
        /*实际结点名称，虚拟节点名称，虚拟节点在环上的位置 */
        unordered_map<string,unordered_map<string,vector<size_t> > > m_node2v;
        uint16_t m_maxCount;
};

void ConsistentHash::printcircle()
{
    cout<<endl<<"******************hash ring*****************"<<endl;
    for(int idx=0;idx<m_maxCount;idx++)
    {
        cout<<idx<<" nodename="<<m_vNode[idx].m_nodeName<<"  m_valid="<<m_vNode[idx].m_valid<<endl;
    }
    cout<<endl;
}

void ConsistentHash::printConfigInfo()
{
    cout<<endl<<"consistent hash config**********************************"<<endl;


    printcircle();

    for(boost::unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iter=m_node2v.begin();
            iter!=m_node2v.end();iter++)
    {
        cout<<endl<<"************real node:"<<iter->first<<"****************"<<endl;

        boost::unordered_map<string,vector<size_t> > &vNode2Pos=iter->second;
        for(boost::unordered_map<string,vector<size_t> >::iterator iterV=vNode2Pos.begin();iterV!=vNode2Pos.end();iterV++)
        {
            cout<<endl<<"virtual node name:"<<iterV->first<<" count="<<iterV->second.size()<<endl;
            for(size_t idx=0;idx<iterV->second.size();idx++)
                cout<<iterV->second[idx]<<"    ";
        }
        cout<<endl;
    }


}

ConsistentHash::ConsistentHash(uint16_t count):m_maxCount(count)
{
    
}
string ConsistentHash::findNode(const string &key)
{
    uint64_t crckey=Common::crc64(key.c_str(),key.length());
    uint64_t pos=crckey%m_maxCount;
    string result("");
    if (m_vNode[pos].m_valid==EMPTY)
    {
        printf("does'not init ok.....'");
    }
    else
    {
        boost::unordered_map<uint64_t,string>::iterator iter=m_v2eNode.find(m_vNode[pos].m_hashKey);

        if (iter!=m_v2eNode.end())
        {
            return iter->second;
        }
        else
        {
            printf("does't find real node'");
        }
    }
    return result;
}
bool ConsistentHash::init()
{
    if (m_maxCount<=0)
        m_maxCount=NODE_COUNT;
    m_vNode=new Node[m_maxCount];
    
    for(size_t idx=0;idx<m_maxCount;idx++)
    {
        m_vNode[idx].m_valid=EMPTY;
    }


    vector<string> vnodes;
    StringAlgorithms::Split(vnode,":",vnodes);
    vector<string> nodes;
    StringAlgorithms::Split(node,":",nodes);

    size_t circleTimes=vnodes.size()/nodes.size();
    size_t nodeIdx=0;
    size_t adjustPos=0;
    for(size_t idx=0;idx<vnodes.size();idx++)
    {
        uint64_t crckey=Common::crc64(vnodes[idx].c_str(),vnodes[idx].length());
        /*将虚拟结点映射到环上*/
        adjustPos=crckey%m_maxCount;

        while(m_vNode[adjustPos].m_valid==REAL)
        {
            adjustPos=(adjustPos+1)%m_maxCount;
        }

        m_vNode[adjustPos].m_nodeName=vnodes[idx];
        m_vNode[adjustPos].m_hashKey=crckey;
        m_vNode[adjustPos].m_valid=REAL;
        cout<<"nodename="<<vnodes[idx]<<"  adjustPos="<<adjustPos<<endl;
        /*
         * 虚拟结点到实际结点的对应关系
         * */

        size_t realIdx=nodeIdx%nodes.size();
        m_v2eNode[crckey]=nodes[realIdx];


        unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iter=m_node2v.find(nodes[realIdx]);
        if (iter==m_node2v.end())
        {
            vector<size_t> vPosVec;
            vPosVec.push_back(adjustPos);
            unordered_map<string,vector<size_t> > vnode2Pos;
            vnode2Pos[vnodes[idx]]=vPosVec;
            m_node2v[nodes[realIdx]]=vnode2Pos;
        }
        else
        {
            unordered_map<string,vector<size_t> > &vnode2Pos=iter->second;

            unordered_map<string,vector<size_t> >::iterator iterV2Pos=vnode2Pos.find(vnodes[idx]);
            if (iterV2Pos!=vnode2Pos.end())
            {
                vector<size_t> &vPosVec=iterV2Pos->second;
                vPosVec.push_back(adjustPos);
            }
            else
            {
                vector<size_t> vPosVec;
                vPosVec.push_back(adjustPos);
                vnode2Pos[vnodes[idx]]=vPosVec;
            }
        }

        nodeIdx++;
    }
    /*扩展结点,到整个环上*/
    for(uint16_t idx=0;idx<m_maxCount-vnodes.size();)
    {
        /*从任意结点开始*/
        Node node=m_vNode[adjustPos];

        /*结点对应的实际结点对应的所有虚拟结点对应的存储位置*/
        boost::unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iter=m_node2v.find(m_v2eNode[node.m_hashKey]);

        if (iter==m_node2v.end())
            return false;
        /*虚拟结点到环上位置的映射*/
        unordered_map<string,vector<size_t> >&v2Pos=iter->second;
        
        unordered_map<string,vector<size_t> >::iterator iterV2Pos=v2Pos.find(node.m_nodeName);
        {
            vector<size_t> &tmpVec=iterV2Pos->second;

            adjustPos=(1+adjustPos)%m_maxCount;
            while(m_vNode[adjustPos].m_valid==EMPTY)
            {
                tmpVec.push_back(adjustPos);
                m_vNode[adjustPos].m_valid=EXT;
                m_vNode[adjustPos].m_nodeName=node.m_nodeName;
                m_vNode[adjustPos].m_hashKey=node.m_hashKey;
                adjustPos=(1+adjustPos)%m_maxCount;
                idx++;
            }
        }

    }
}
uint64_t ConsistentHash::hash(const string &str,uint64_t &crckey)
{
    crckey=Common::crc64(str.c_str(),str.length());
    return crckey%m_maxCount;
}
bool ConsistentHash::addNode(vector<string> vnodes,string nodeName)
{
    unordered_map<string,vector<size_t> > v2PosMap;
    for(size_t idx=0;idx<vnodes.size();idx++)
    {
        uint64_t crckey=0;
        size_t adjustPos=hash(vnodes[idx],crckey);
        /*调整pos到一个扩展节点上 */
        while(m_vNode[adjustPos].m_valid==REAL)
        {
            adjustPos++;
        }

        Node node=m_vNode[adjustPos];
        size_t coveredCount=0;

        m_vNode[adjustPos].m_nodeName=vnodes[idx];
        m_vNode[adjustPos].m_hashKey=crckey;
        m_vNode[adjustPos].m_valid=REAL;


        vector<size_t> posVec;
        posVec.push_back(adjustPos);
        coveredCount++;
        adjustPos=(1+adjustPos)%m_maxCount;
        while(node.m_hashKey==m_vNode[adjustPos].m_hashKey)
        {
            m_vNode[adjustPos].m_hashKey=crckey;
            m_vNode[adjustPos].m_nodeName=vnodes[idx];
            m_vNode[adjustPos].m_valid=EXT;
            posVec.push_back(adjustPos);

            adjustPos=(1+adjustPos)%m_maxCount;
            coveredCount++;
        }
        m_v2eNode[crckey]=nodeName;
        v2PosMap[vnodes[idx]]=posVec;

        releaseExtNodes(node,vnodes[idx],coveredCount);
    }

    m_node2v[nodeName]=v2PosMap;
    return true;
}
void ConsistentHash::releaseExtNodes(Node &node,string &vnodeName,size_t vCount)
{
    unordered_map<uint64_t,string>::iterator iter= m_v2eNode.find(node.m_hashKey);
    string realNode("");
    if (iter!=m_v2eNode.end())
    {
        realNode=iter->second;
    }
    else
    {
        return;
    }
    
    unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iterNodes=m_node2v.find(realNode);
    if (iterNodes!=m_node2v.end())
    {
        unordered_map<string,vector<size_t> >::iterator iter=iterNodes->second.find(node.m_nodeName);
        vector<size_t> &vpos=iter->second;
        /*升序排序*/
        std::sort(vpos.begin(),vpos.end());
        vpos.resize(vpos.size()-vCount);
    }
    else
    {
        return;
    }

}
bool ConsistentHash::removeNode(string node)
{
    /*
     * 找到删除节点对应的所有虚拟节点
     * */
    boost::unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iter=m_node2v.find(node);
    for(unordered_map<string,vector<size_t> >::iterator iterV2Pos=iter->second.begin();iterV2Pos!=iter->second.end();iterV2Pos++)
    {
        /*
         * 循环处理各个虚拟节点
         * */

        //当前虚拟节点对应环上所位置
        vector<size_t> &vpos=iterV2Pos->second;

        // 对位置排序,
        size_t vecLength=vpos.size();

        size_t idx=0;
        /*找上一个虚拟结点的位置*/
        size_t lastPos=(vpos[0]-1)>0?vpos[0]-1:m_maxCount;
        Node lastNode=m_vNode[lastPos];
        
        {
            /*
             * 当前节点对应的实际节点名称
             * */
            Node curNode=m_vNode[vpos[idx]];

            /*
             * 取前一个节点的实际节点名称
             * */
            unordered_map<uint64_t,string>::iterator iterV2R= m_v2eNode.find(lastNode.m_hashKey);
            string realNode("");
            if (iterV2R!=m_v2eNode.end())
            {
                realNode=iterV2R->second;
            }
            else
            {
                continue;
            }
            /*
             * 根据前一个节点的实际节点名称,找到其对应的所有虚拟节点
             * */
            unordered_map<string,unordered_map<string,vector<size_t> > >::iterator iterNodes=m_node2v.find(realNode);
            unordered_map<string,vector<size_t> >&tVposMap=iterNodes->second;

            /*
             *在前一个节点的虚拟节点中找到前一个节点的虚拟节点数组
             * */
            unordered_map<string,vector<size_t> >::iterator iterVec=tVposMap.find(lastNode.m_nodeName);
            vector<size_t> &tVpos=iterVec->second;
            /*
             * 将当前虚拟节点的第一个位置存储到前一个节点的位置数组，同时修改当前节点环中的信息
             * */ 
            tVpos.push_back(vpos[idx]); 
            
            m_vNode[vpos[idx]].m_hashKey=lastNode.m_hashKey;
            m_vNode[vpos[idx]].m_valid=lastNode.m_valid;
            m_vNode[vpos[idx]].m_nodeName=lastNode.m_nodeName;
            
            idx++;
            size_t nextPos=vpos[idx];
            /*
             * 循环前当前删除节点在环中的数据修改为前一个节点
             * */
            while(idx<vpos.size() && m_vNode[nextPos].m_hashKey==curNode.m_hashKey)
            {
                tVpos.push_back(nextPos);
                m_vNode[nextPos].m_hashKey=lastNode.m_hashKey;
                m_vNode[nextPos].m_valid=EXT;
                m_vNode[nextPos].m_nodeName=lastNode.m_nodeName;
                idx++;
                nextPos=vpos[idx];
            }
            
            vector<size_t>().swap(vpos);
            m_v2eNode.erase(curNode.m_hashKey);
        }
        
    }
    
    m_node2v.erase(node);
    return true;
}
int main(int argc,char *argv[])
{
    ConsistentHash *ch=new ConsistentHash(100);
    /*初始化环路*/
    ch->init();
    /*打印配置信息*/
    ch->printConfigInfo();

    vector<string> vnode;
    vnode.push_back("vnode17");
    vnode.push_back("vnode16");
    ch->addNode(vnode,"172.16.73.55");
    cout<<endl<<"print after add....................."<<endl;
    ch->printConfigInfo(); 

    ch->removeNode("172.16.73.55");
    cout<<endl<<"print after remove....................."<<endl;
    ch->printConfigInfo();
   

    cout<<endl<<"print after remove 172.16.73.194....................."<<endl;
    ch->removeNode("172.16.73.194");
    ch->printConfigInfo();

    cout<<endl<<"print after remove 172.16.73.68....................."<<endl;
    ch->removeNode("172.16.73.68");
    ch->printConfigInfo();
    string key("123");
    printf("%s",ch->findNode(key).c_str());
    return 0;
}


 

 

NBtingwu
关注
专栏目录
一致性Hash算法的实现
wangyan9110's Blog
04-15 8668
一致性hash作为一个负载均衡算法，可以用在分布式缓存、数据库的分库分表等场景中，还可以应用在负载均衡器中作为作为负载均衡算法。在有多台服务器时，对于某个请求资源通过hash算法，映射到某一个台服务器，当增加或减少一台服务器时，可能会改变这些资源对应的hash值，这样可能导致一部分缓存或数据失效了。一致性hash就是尽可能在将同一个资源请求路由到同一台服务器中。本篇文章将模拟实现一个分布式缓存系统来
一致性hash算法的实现
wang_ze的博客
04-23 339
一致性hash算法的实现特点 分布均匀 且有一定范围     不能重复步骤 1.首先求出memcached服务器（节点）的哈希值，并将其配置到0～232的圆（continuum）上。2.然后采用同样的方法求出存储数据的键的哈希值，并映射到相同的圆上。3.然后从数据映射到的位置开始顺时针查找，将数据保存到找到的第一个服务器上。如果超过232仍然找不到服务器，就会保存到第一台memcached服务器上...
哈希算法的核心
nbxuwentao的博客
06-15 413
将任意长度的二进制值串映射为固定长度的二进制值串：能理解就差不多类，也就是这个原理
5行代码实现一致性哈希
gongyiling3468的专栏
08-20 1171
你没看错，5行代码实现一致性哈希！好吧，我发现我真是越来越噱头了，原理请自行google，我自己分析了下，特分享出来，这个的一个缺点是加减机器只能从最右开始。 #include int32_t JumpConsistentHash(uint64_t key, int32_t num_buckets) { int64_t b = -1, j = 0; while (j
数据结构专项之Hash函数
hunteagle的小站
08-31 1534
数据结构专项之Hash函数 2007/01/13 作者：冲出宇宙 from Hour41 (www.hour41.com) 计算理论中，没有Hash函数的说法，只有单向函数的说法。所谓的单向函数，是一个复杂的定义，大家可以去看计算理论或者密码学方面的数据。用“人类”的语言描述单向函数就是：如果某个函数在给定输入的时候，很容易计算出其结果来；而当给定结果的时候，很难计算出输入来，这就是单项函数。...
Hash算法的经典实现
chenqiang35的专栏
02-16 1029
原文出处：http://blog.minidx.com/2008/01/27/446.html原文作者：Minidxer      哈希算法将任意长度的二进制值映射为固定长度的较小二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是
hash实现--开放寻址方式
如果你知道去哪里，全世界都会为你让路
11-30 2473
   今天看了一下《算法导论》第十一章的散列表，里面有一节是关于开发寻址方式。  下面是我的简单的实现：   static const int __stl_num_primes = 28;static const unsigned long __stl_prime_list[__stl_num_primes] ={ 53, 97, 193,
Ketama一致性Hash算法(含Java代码) 1
08-03
Ketama一致性哈希算法是基于一致性哈希的一种优化实现，主要解决了传统一致性哈希中节点分布不均匀的问题。在Ketama中，每个实际的物理服务器会被映射到多个虚拟节点，通常是100到200个，这些虚拟节点均匀分布在环上...
一个根据google maglev 论文,用c语言实现的一致性hash算法.zip
最新发布
06-14
一致性哈希算法是一种分布式系统中负载均衡的策略，它的核心思想是解决在分布式环境中如何将数据均匀地分配到各个节点的问题。Google Maglev论文中提出的一致性哈希算法是为了解决大型数据中心的网络路由问题，使得...
PHP一致性hash分布式算法封装类定义与用法示例
01-20
一致性哈希(Consistent Hashing)是一种分布式算法，主要用于解决分布式缓存、负载均衡等问题，其核心思想是在多台服务器之间分配数据或请求时，尽可能地保持数据的存储位置不变，即使在服务器增减时，也只有少量的...
PHP实现的一致性哈希算法完整实例
12-19
一致性哈希算法是一种分布式哈希算法，用于在分布式系统中解决数据存储和检索的问题，确保在节点加入或离开时，尽可能少地改变已有的数据分布。这种算法在内容分发网络（CDN）、数据库分片等领域有着广泛的应用。在...
Java语言Consistent Hash算法学习笔记（代码示例）
08-28
一致性哈希算法是一种分布式哈希表（Distributed Hash Table, DHT）的解决方案，它主要应用于分布式缓存、负载均衡等领域。在Java中，一致性哈希算法能够解决节点动态增减时，数据映射关系的稳定性和高效性问题。...
LFU算法
热门推荐
Searcher_Recommeder的博客
03-30 1万+
1，基本原理LFU（Least Frequently Used）算法根据数据的历史访问频率来淘汰数据，其核心思想是“如果数据过去被访问多次，那么将来被访问的频率也更高”。LFU的每个数据块都有一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。具体实现如下： 1. 新加入数据插入到队列尾部（因为引用计数为1）；2. 队列中的数据被访问后，引用计数增加，队列重新排序；3...
基本算法，求交集
Searcher_Recommeder的博客
06-17 2778
一，交集运算算法          求多列数据的交集是一种应用广泛应用的算法，例如在搜索应用中，一个搜索关键词被分成了多个Term，每个Term对应一个倒排链表，那个整个搜索关键词的 搜索结果就是各个Term对应倒排链表元素的交集。 二，算法 /*************************************************************************
storm中的RotatingCache技术
Searcher_Recommeder的博客
04-12 1194
一，基本的原理 　　偶遇storm中的rotatecache算法，特地研究一下。 　　核心： 　　1，是采用了链表来组织多个桶来存储数据； 　　 2，插入数据时直接插入到第一个桶中，清除到其它桶中的同key值的数据； 　　3，删除数据移除所有桶中的数据（此处需要遍历） 　　4，回收数据的时候，采用了非常巧妙的方式，在链表头新加一个桶，删除尾部的桶删除掉，如果带回调，调用一下回调函数。
最大，最小值问题，前K个数问题，利用mapreduce解决方案
Searcher_Recommeder的博客
11-21 1014
1，MapReduce求最大最小值问题  要想一次求得最大最小值，必须只有一个reduce  MAP类 (1)Map类中增加两个变量，max,min (2)map函数中用取得的当前行的数据和max,min做比较，更新数据。 (3)clear函数中将max,min输出，输出格式为    &lt;max,n1&gt; &lt;min,n2&gt;   Reduce类  (1)直接比较list中的最...
基本算法-MD5
Searcher_Recommeder的博客
06-27 746
一，描述        MD5报文摘要生成算法在数据安全和通信领域有着广泛的应用，最早应用于信息传输过程中防止数据被中间修改，一直到现在的存储领域做为文件的指纹来实现一些更加复杂的功能，比如视频网站，新视频上传的时候会生成一个视频对应的MD5指纹，后继再有同样的视频上传的时候通过md5指纹就可以判断当前上传的视频是否已经被上传过，通过这种办法即可实现秒传视频。 二，库      linux的
常用算法之-快速排序
Searcher_Recommeder的博客
06-05 570
一，快速排序      快速排序做为o(nlogn)的内存排序算法，在日常工作和工作面试过程中出镜率也是相当的高。      最差的情况是快速排序的时间复杂度会下降到冒泡的级别，即 o(n*n)       有一些方法来规避这个问题，比如选择随机的枢纽记录。       下出给出了一个，固定枢纽记录的方法。 二，C++代码 /******************************
深度解析：Java实现一致性Hash算法
"对一致性Hash算法的深入研究，包括Java代码实现" 一致性Hash算法是一种分布式缓存和负载均衡的解决方案，它的主要目标是在增加或减少服务器节点时，尽可能少地改变已有的数据到服务器的映射关系，从而提高系统的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值