HashMap Java 和 C++的实现比较

最新推荐文章于 2021-12-30 11:08:12 发布
最新推荐文章于 2021-12-30 11:08:12 发布
阅读量2.2k 收藏
点赞数
分类专栏： C/C++学习 文章标签： HashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crispy_rice/article/details/18410361
版权

1. Java中Map/HashMap/TreeMap的分析

Map/HashMap其存储是没有顺序的，而TreeMap则是有序存储。

参考链接：

http://blog.csdn.net/devillyd/article/details/3135479

http://coolshell.cn/articles/9703.html

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Hashtable;
import java.util.TreeMap;
class  HashMaps
{
       public static void main(String[] args)
      {
            Map map=new HashMap();           
            map.put("a", "aaa");
            map.put("b", "bbb");
            map.put("c", "ccc");
            map.put("d", "ddd");
          
            Iterator iterator = map.keySet().iterator();           
            while (iterator.hasNext()) {
             Object key = iterator.next();
             System.out.println("map.get(key) is :"+map.get(key));
            }      
           
           
           
            Hashtable tab=new Hashtable();           
            tab.put("a", "aaa");
            tab.put("b", "bbb");
            tab.put("c", "ccc");
            tab.put("d", "ddd");
            Iterator iterator_1 = tab.keySet().iterator();
            while (iterator_1.hasNext()) {
             Object key = iterator_1.next();
             System.out.println("tab.get(key) is :"+tab.get(key));
            }        
           
            TreeMap tmp=new TreeMap();           
            tmp.put("a", "aaa");
            tmp.put("b", "bbb");
            tmp.put("c", "ccc");
            tmp.put("d", "ddd");
            Iterator iterator_2 = tmp.keySet().iterator();
            while (iterator_2.hasNext()) {
             Object key = iterator_2.next();
             System.out.println("tmp.get(key) is :"+tmp.get(key));
            }        
                     
        
       }
    
}
运行结果如下： 

map.get(key) is :ddd
map.get(key) is :bbb
map.get(key) is :ccc
map.get(key) is :aaa
tab.get(key) is :bbb
tab.get(key) is :aaa
tab.get(key) is :ddd
tab.get(key) is :ccc
tmp.get(key) is :aaa
tmp.get(key) is :bbb
tmp.get(key) is :ccc
tmp.get(key) is :ddd

2.GCC下C++ HashMap的表达


hash_map散列表本身不在ISO的STL和C++标准库中，不属于标准的一部分，不适用于跨编译器使用。一个编译器能用，另一个可能不能用。比如gcc下，hash_map已经被归为旧版兼容的工具，需要用__gnu_cxx::hash_map名字空间才能使用，而非标准的std::推荐用符合ISO标准map容器(红黑树表)替代。如果没有明显的性能差距，多用map而不是hash_map。


按照hashmap的基本原理用C++实现了简单的基本功能，复杂的实现参考C++库的源码，C++最新的标准库里已经有以下四种基于hashtable的容器：

unordered_set(C++11)unordered_multiset(C++11)unordered_map(C++11)unordered_multimap (C++11)。

具体参考：http://en.cppreference.com/w/

http://www.cnblogs.com/luxiaoxun/archive/2012/09/02/2667782.html 


#include <string>
#include <iostream>
#include <ext/hash_map>
using namespace std;
using namespace __gnu_cxx;

struct str_hash {
    size_t operator() (const string & s) const {
        return __stl_hash_string(s.c_str());
}};

struct str_compare {
    int operator() (const string & a, const string & b) const {
        return (a == b);
}};
typedef hash_map < string, string, str_hash, str_compare > StrMap;

int main()
{
    StrMap strMap;
    string a, b;
    cout << "鎻掑叆:" << endl;
    while (cin >> a >> b) {
        if (a.length() <= 1)
            break;
        strMap.insert(make_pair(a, b));
    }
    cout << "鏌ヨ:" << endl;
    while (cin >> a) {
        if (a.length() <= 1)
            break;
        if (strMap.find(a) != strMap.end())
            cout << strMap[a] << endl;
        else
            cout << "not found" << endl;
    }
    return 0;
}

利用unordered_map实现如下：

/*
 * =====================================================================================
 *
 *       Filename:  unordered_map.cc
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  2014年01月17日 16时38分01秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  lishuming (think different and do it with plearsure.), lism2013@hotmail.com
 *   Organization:  RADI A401
 *
 * =====================================================================================
 */

#include <iostream>
#include <unordered_map>
#include <string>
 using namespace std;

unsigned int JSHash(const char *str)
{
    unsigned int hash = 1315423911;
    while (*str)
    {
    	hash ^= ((hash << 5) + (*str++) + (hash >> 2));
    }
    return (hash & 0x7FFFFFFF);
}

struct StrHash {
    size_t operator() (const string & s) const {
    	return JSHash(s.c_str());
}};
struct StrCompare {
    bool operator() (const string & a, const string & b) const {
	return a == b;
}};
typedef unordered_map < string, string, StrHash, StrCompare > MyMap;
int main()
{
    MyMap mymap;
    string a, b;
    while (cin >> a >> b)
    {
      	mymap[a] = b;
    }
    for (MyMap::iterator it = mymap.begin(); it != mymap.end(); ++it)
	      cout << it->first << " " << it->second << endl;
    return 0;
}


HashMap 利用C++的具体实现

/*
 * =====================================================================================
 *
 *       Filename:  HashMap.h
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  2014年01月17日 16时56分40秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  lishuming (think different and do it with plearsure.), lism2013@hotmail.com
 *   Organization:  RADI A401
 *
 * =====================================================================================
 */
/*
    * HashMap.h
     * Author: luxiaoxun
      */

#ifndef HASHMAP_H_
#define HASHMAP_H_

#include <iostream>
using namespace std;

//List all the integer number no less than 57 total number is 28
//And each number is about half of its next number
static int prime[28] = {
    57, 97, 193, 389, 769,
    1543, 3079, 6151, 12289, 24593,
    49157, 98317, 196613, 393241, 786433,
    1572869, 3145739, 6291469, 12582917, 25165843,
    50331653, 100663319, 201326611, 402653189, 805306457,
};

class HashMapUtil {
  public:
    static int find_NextPrimeNumber(int current) {
	//Find the next prime number by searching in the prime number list
	int i = 0;
	for (; i < 28; i++)
	    if (current < prime[i])
		 break;
	 return prime[i];	//return the next larger prime.
    }
};

template < class Key, class Value, class HashFunc, class EqualKey >
    class HashMap
{
  private:
    template < class _Key, class _Value > class KeyNode
    {
      public:
	_Value value;		//Store the value
	_Key key;		//Store the keyword
	int used;
	//if the type of Value/Key is your own class, make sure they can handle copy constructor and operator =
      KeyNode():used(0)
	{
	}
	KeyNode(const KeyNode & kn) {
	    value = kn.value;
	    key = kn.key;
	    used = kn.used;
	}
	KeyNode & operator=(const KeyNode & kn) {
	    if (this == &kn)
		return *this;
	    value = kn.value;
	    key = kn.key;
	    used = kn.used;
	    return *this;
	}
    };

  public:
    HashMap();
    ~HashMap();
    bool insert(const Key & hashKey, const Value & value);
    bool remove(const Key & hashKey);
    void rehash();		//use it when rehashing
    Value & find(const Key & hashKey);
    const Value & operator [] (const Key & hashKey) const;
    Value & operator [](const Key & hashKey);

  private:
    HashFunc hash;
    EqualKey equal;
    HashMapUtil hml;
    KeyNode < Key, Value > *table;
    int size;			//current number of itmes
    int capacity;		//capacity of the array
    static const double loadingFactor;
    int findKey(const Key & hashKey);	//find the index of a key
};

template < class Key, class Value, class HashFunc, class EqualKey >
    const double HashMap < Key, Value, HashFunc,
    EqualKey >::loadingFactor = 0.9;

template < class Key, class Value, class HashFunc, class EqualKey >
    HashMap < Key, Value, HashFunc, EqualKey >::HashMap()
{
    hash = HashFunc();
    equal = EqualKey();
    hml = HashMapUtil();
    capacity = hml.find_NextPrimeNumber(0);	//initialize the capacity with first primer 57
    //resize the table with capacity because an extra one is used
    //to return the NULL type of Value in the function find
    table = new KeyNode < Key, Value >[capacity + 1];
    for (int i = 0; i < capacity; i++)	//initialize the table
	table[i].used = 0;
    size = 0;
}

template < class Key, class Value, class HashFunc, class EqualKey >
    HashMap < Key, Value, HashFunc, EqualKey >::~HashMap()
{
    delete[]table;
}

template < class Key, class Value, class HashFunc, class EqualKey >
    bool HashMap < Key, Value, HashFunc,
    EqualKey >::insert(const Key & hashKey, const Value & value)
{
    int index = hash(hashKey) % capacity;
    //cout<<"Index is "<<index<<endl;
    if (table[index].used == 1)	//the key-value's hash is unique
    {
	//cout<<"The key-value must be unique!"<<endl;
	return false;
    }
    table[index].used = 1;	//modify the KeyNode
    table[index].key = hashKey;
    table[index].value = value;

    size++;
    //if the table's size is too large ,then rehash it
    if (size >= capacity * loadingFactor)
	rehash();
    return true;
}

template < class Key, class Value, class HashFunc, class EqualKey >
    void HashMap < Key, Value, HashFunc, EqualKey >::rehash()
{
    int pastsize = capacity;
    //create a new array to copy the information in the old table
    capacity = hml.find_NextPrimeNumber(capacity);
    KeyNode < Key, Value > *tmp = new KeyNode < Key, Value >[capacity];
    for (int i = 0; i < pastsize; i++)
    {
	if (table[i].used == 1)	//copy the KeyNode into the tmp array
	{
	    tmp[i] = table[i];
	}
    }
    delete[]table;		//release the memory of the old table

    table = new KeyNode < Key, Value >[capacity + 1];	//resize the table
    for (int i = 0; i < capacity; i++)	//initialize the table
    {
	table[i].used = 0;
    }
    for (int i = 0; i < pastsize; i++)	//insert the item into the table one by one
    {
	if (tmp[i].used == 1)
	    insert(tmp[i].key, tmp[i].value);
    }
    delete[]tmp;		//delete the tmp array
}

template < class Key, class Value, class HashFunc, class EqualKey >
    bool HashMap < Key, Value, HashFunc,
    EqualKey >::remove(const Key & hashKey)
{
    int index = findKey(hashKey);	//find the index of the key
    if (index < 0)		//if find modify the flag with 0,else print out "no such key!"
    {
	cout << "No such Key!" << endl;
	return false;
    } else
    {
	table[index].used = 0;
	size--;
	return true;
    }
}

template < class Key, class Value, class HashFunc, class EqualKey >
    Value & HashMap < Key, Value, HashFunc,
    EqualKey >::find(const Key & hashKey)
{
    int index = findKey(hashKey);
    if (index < 0)		//if index <0 ,not found,else return the index
    {
	cout << "can not find the key!" << endl;
	return table[capacity].value;	//return NULL
    } else
    {
	return table[index].value;
    }
}

template < class Key, class Value, class HashFunc, class EqualKey >
    const Value & HashMap < Key, Value, HashFunc,
    EqualKey >::operator[] (const Key & hashKey)
const {
    return find(hashKey);	//overload the operation to return the value of the element
}
template < class Key, class Value, class HashFunc, class EqualKey >
    Value & HashMap < Key, Value, HashFunc,
    EqualKey >::operator[] (const Key & hashKey)
{
    return find(hashKey);	//overload the operation to return the value of the element
}

template < class Key, class Value, class HashFunc, class EqualKey >
    int HashMap < Key, Value, HashFunc,
    EqualKey >::findKey(const Key & hashKey)
{
    int index = hash(hashKey) % capacity;
    if ((table[index].used != 1) || !equal(table[index].key, hashKey))
	return -1;
    else
	return index;
}

#endif				/* HASHMAP_H_ */

/*
 * =====================================================================================
 *
 *       Filename:  HahMap.cpp
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  2014年01月17日 16时57分03秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  lishuming (think different and do it with plearsure.), lism2013@hotmail.com
 *   Organization:  RADI A401
 *
 * =====================================================================================
 */

#include "HashMap.h"
#include <string>
#include <iostream>
using namespace std;

//Hash function you provided must be correspond to the type of the Key
class HashFunc {
  public:
    int operator() (const string & key) {
	int hash = 0;
	for (int i = 0; i < key.length(); ++i)
	{
	    hash = hash << 7 ^ key[i];
	} return (hash & 0x7FFFFFFF);
    }
};

//Equal function you provided to check whether two Keys are equal
//must be correspond to the type of the Key
class EqualKey {
  public:
    bool operator() (const string & A, const string & B) {
	if (A.compare(B) == 0)
	    return true;	//if equal return true
	else
	    return false;	//else false
}};

int main()
{
    HashMap < string, string, HashFunc, EqualKey > hm;

    hm.insert("hello", "you");
    hm.insert("why", "dream");
    hm.insert("java", "good");
    hm.insert("welcome", "haha");

    hm.insert("welcome", "hehe");	//error, key-value must be unique


    cout << "after insert:" << endl;
    cout << hm.find("welcome") << endl;
    cout << hm.find("java") << endl;
    cout << hm["why"] << endl;
    cout << hm["hello"] << endl;

    if (hm.remove("hello"))
	cout << "remove is ok" << endl;	//remove is ok
    cout << hm.find("hello") << endl;	//not exist print NULL

    hm["why"] = "love";		//modify the value 
    cout << hm["why"] << endl;

    return 0;
}


Rilakkuma
关注
专栏目录
C++，Java中的Hashmap与python中的dict比较
weixin_39390393的博客
04-17 5178
0. 前言 之前在做leetcode的两数之和，用三种不同的语言进行了研究。思路都是用key-value形式的数据结构：C++、Java是Hashmap，在Python里面是字典。这篇文章我们就分析一下这几种不同语言下的数据结构。 1. C++ 中的 map & unoerdered_map 我们这里讨论的结构来源于STL标准模板库。 先说STL：它是于1994年正式成为ANSI/ISO ...
hashmap的C++实现
QtCompany的博客
02-15 964
按照hashmap的基本原理用C++实现了简单的基本功能，复杂的实现参考C++库的源码，C++最新的标准库里已经有以下四种基于hashtable的容器： unordered_set (C++11) unordered_multiset (C++11) unordered_map (C++11) unordered_multimap (C++11)。
C++ hash_map 与 Java HashMap 的区别
mdj67887500的专栏
10-26 7832
与Java中的HashMap比起来， C++ STL 中hash_map的实现并不是很完美。原因在于一些小的细节： 1. Hash表的增长方式：      hash_map： 当元素数量element_NUM超过桶的数量bucket_NUM 时，确定一个新的桶数量N。N是质数，它是从一个质数表中选择出来的，它必须大于等于元素数量element_NUM。质数表中的质数是从小到大排列的，基本上后一
C++的hashmap和Java的hashmap
weixin_33910137的博客
02-26 511
C++里面是这样的：typedef std::unordered_map&lt;std::string,std::string&gt; stringmap; std::unordered_map&lt;std::string,double&gt;::const_iterator got = mymap.find (input); std::pair&lt;std::string,double&gt...
ConsistentHash:一致性hash算法的 java 和 C++ 实现
05-14
总的来说，理解和实现一致性哈希是理解分布式系统中数据存储和检索的关键，无论是在Java还是C++环境中，都可以通过合适的哈希函数和数据结构来实现这一算法，从而优化分布式服务的性能和稳定性。
JavaDataStructures:数据结构在 Java 和 C++ 中的实现
06-30
在这个“JavaDataStructures”项目中，重点是展示了数据结构在Java和C++这两种流行编程语言中的实现。下面我们将详细探讨数组列表、哈希表、弹性堆和二叉树这四种数据结构。 1. **数组列表**（ArrayList）： - 在...
A*算法Java/C++实现
05-10
总的来说，理解和实现A*算法需要对图论、数据结构和搜索算法有深入的理解。在Java和C++中实现A*算法，可以提高我们对这两种语言特性的掌握，同时也为我们提供了一个强大的工具，用于解决游戏路径规划、机器人导航、...
Java转C++代码工具 J2C的jar包
05-14
Java的动态绑定在C++中通常通过虚函数实现。 3. 异常处理：Java的try-catch-finally结构会转换为C++的异常处理机制，即try-catch块。 4. 内存管理：Java的自动垃圾回收在C++中不再存在，因此，开发者需要手动管理...
Hashmap C++实现
Step by step
03-12 1313
了解一下hashmap的写法！(有时候出题人会故意卡这个~~)     const int HASH = 1000007; struct HASHMAP { int head[HASH],next[MAXN],size; long long state[MAXN]; void init() { size = 0; memset(he
Java HashMap和C++ map的用法区别（插入键值对元素、根据key修改value）
NewsomTech
03-03 931
文章目录1 Java HashMap修改实值2 C++ map修改实值 需求：根据键值key修改对应的实值value。 若键存在，则值加1；若键不存在，则创建该键，并将键对应的值赋为1。 1 Java HashMap修改实值 Java的HashMap使用put()方法插入键值对元素<key, value>时，若键key相同，则会使用新值value覆盖之前的数据。 实现代码： 先判断键是否存在： ①键存在：先使用get()方法获取原值，加1后使用put()方法插入键值对元素，会覆盖旧值； ②键
map 与 hash_map 性能比较
Sky_qing的专栏
07-26 3161
由于工作需要，最近不得不关注 map 与 hash_map 的性能，于是花了两天的功夫验证了一下，下面把验证的结果贴出来，给大家看看，希望对大家有帮助。 我主要对 map 和 hash_map 的插入、查询、遍历、清除（也就是清空）作了对比。 先来看一下我的源程序（可以直接在Windows下编译）： #include #include #include #include
java Map 的理解： 和C++的map一模一样
12-16 395
java 中 Map 和C++的map一模一样， 只不过，C++ 中map全是小写，java中，头一个字母为大写。 java Map 的例程如下： Map<String, String> para = new HashMap<>();
HashMap的C++实现
weixin_34184158的博客
08-19 183
#include <iostream> #include <cstring> #include <string> typedef unsigned int SIZE_T; using namespace std; /** HashMap模板的C++实现，用拉链法解决冲突 *注意：需要为每一种KeyType两个仿函数：HashFunc and...
c++中map插入数据_Java中常见数据结构Map之HashMap
weixin_30789053的博客
01-27 381
一：JDK7中的HashMap：HashMap底层维护一个数组table， 数组中的每一项是一个key，value形式的Entry。我们往HashMap中所放置的对象实际是存储在该数组中。Map中的key，value则以Entry的形式存放在数组中。这个Entry应该放在数组的哪一个位置上， 是通过key的hashCode来计算的。这个位置也成为hash桶。通过hash计算出来的值将通过index...
C++模拟实现HashMap
navy专栏
12-30 785
#ifndef _HASHMAP_H #define _HASHMAP_H template<class Key, class Value> class HashNode { public: Key _key; Value _value; HashNode *next; HashNode(Key key, Value value) { _key = key; _value = value; next = ...
[C++]HashMap实现STL map
stary_yan的博客
06-05 2702
用HashMap实现STL map在STL中map是用RB Tree（也就是红黑树）来完成的。本文尝试用HashMap来实现map。问题产生本文主要是完成以下interface：#ifndef HASHMAP_HPP #define HASHMAP_HPP #include <vector> #include <list> #include <utility> #include <iostream>
C++中替代Java中的哈希的替代结构__unordered_map
HappyHeavyRain的博客
05-12 780
你不能不知道的秘密--hashc++的替代品使用unordered_map对比与map对比需要引入的头文件不同内部实现机理不同优缺点以及适用处总结： c++的替代品 C++ 11标准中加入了unordered系列的容器。unordered_map记录元素的hash值，根据hash值判断元素是否相同。map相当于java中的TreeMap，unordered_map相当于HashMap。无论从查找、插入上来说，unordered_map的效率都优于hash_map，更优于map；而空间复杂度方面，hash_m
c++hashmap底层实现原理
最新发布
09-04
HashMap是Java中常用的数据结构之一，它基于哈希表（Hash Table）实现。下面是HashMap的底层实现原理： 1. 数据结构：HashMap是由数组和链表/红黑树组合而成的。数组用于存储元素，链表/红黑树用于解决哈希冲突的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值