1.Two Num | LeetCode OJ（浅谈hash_map，和map）

September 23, 2016
作者：dengshuai_super
出处：http://blog.csdn.net/dengshuai_super/article/details/52636684
声明：转载请注明作者及出处。

---

1. Two Sum  
QuestionEditorial Solution  My Submissions
Total Accepted: 304011
Total Submissions: 1134246
Difficulty: Easy
Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution.

Example:
Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

答案来自LeetCode论坛：

//C++
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> mapping;
        //map mapping;
        vector<int> result;
        for (int i = 0; i < nums.size(); i++) {
        mapping[nums[i]] = i;
        }
        for (int i = 0; i < nums.size(); i++) {
        const int gap = target - nums[i];
        if (mapping.find(gap) != mapping.end() && mapping[gap] > i) {
        result.push_back(i );
        result.push_back(mapping[gap]);
        break;
        }
        }
        return result;

    }
};

//C
typedef struct HashNode {
    int key;
    int val;
} HashNode;

typedef struct HashMap {
    int size;
    HashNode** storage;
} HashMap;

HashMap* hash_create(int size);
void hash_destroy(HashMap* hashMap);
void hash_set(HashMap* hashMap, int key, int value);
HashNode* hash_get(HashMap* hashMap, int key);

HashMap* hash_create(int size){
    HashMap* hashMap = malloc(sizeof(HashMap));
    hashMap->size = size;
    hashMap->storage = calloc(size, sizeof(HashNode*));
    return hashMap;
}

void hash_destroy(HashMap* hashMap) {
    for(int i; i < hashMap->size; i++) {
        HashNode *node;
        if((node = hashMap->storage[i])) {
            free(node);
        }
    }
    free(hashMap->storage);
    free(hashMap);
}

void hash_set(HashMap *hashMap, int key, int value) {
    int hash = abs(key) % hashMap->size;
    HashNode* node;
    while ((node = hashMap->storage[hash])) {
        if (hash < hashMap->size - 1) {
            hash++;
        } else {
            hash = 0;
        }
    }
    node = malloc(sizeof(HashNode));
    node->key = key;
    node->val = value;
    hashMap->storage[hash] = node;
}

HashNode* hash_get(HashMap *hashMap, int key) {
    int hash = abs(key) % hashMap->size;
    HashNode* node;
    while ((node = hashMap->storage[hash])) {
        if (node->key == key) {
            return node;
        }

        if (hash < hashMap->size - 1) {
            hash++;
        } else {
            hash = 0;
        }
    }

    return NULL;
}

int* twoSum(int* nums, int numsSize, int target) {
    HashMap* hashMap;
    HashNode* node;
    int rest, i;

    // make the hashMap 2x size of the numsSize
    hashMap = hash_create(numsSize * 2);
    for(i = 0; i < numsSize; i++) {
        rest = target - nums[i];
        node = hash_get(hashMap, rest);
        if (node) {
            int* result = malloc(sizeof(int)*2);
            result[0] = node->val + 1;
            result[1] = i + 1;
            hash_destroy(hashMap);
            return result;
        } else {
            hash_set(hashMap, nums[i], i);
        }
    }
}

---

1.1 hash_map和map的区别在哪里？

构造函数。hash_map需要hash函数，等于函数；map只需要比较函数(小于函数).
存储结构。hash_map采用hash表存储，map一般采用红黑树(RB Tree)实现。因此其memory数据结构是不一样的。
关于hash_map，它与map的实现机制是不一样的，map内部一般用树来实现，其查找操作是O(logN)的。
hash_map的查找，内部是通过一个从key到value的运算函数来实现的，这个函数“只接受key作为参数”，也就是说，hash_map的查找 算法与数据量无关，所以认为它是O(1)级的。

1.2 什么时候需要用hash_map，什么时候需要用map?

总体来说，hash_map 查找速度会比map快，而且查找速度基本和数据数据量大小，属于常数级别;而map的查找速度是log(n)级别。并不一定常数就比log(n)小，hash还有hash函数的耗时，明白了吧，如果你考虑效率，特别是在元素达到一定数量级时，考虑考虑hash_map。但若你对内存使用特别严格，希望程序尽可能少消耗内存，那么一定要小心，hash_map可能会让你陷入尴尬，特别是当你的hash_map对象特别多时，你就更无法控制了，而且hash_map的构造速度较慢。

权衡三个因素: 查找速度, 数据量, 内存使用。

在不碰撞的情况下，hash_map是所有数据结构中查找最快的，它是常数级的。
注意我的前提：“在不碰撞的情况下”，其实换句话说，就是要有足够好的hash函数，它要能使key到value的映射足够均匀，否则，在最坏的情况下，它的计算量就退化到O(N)级，变成和链表一样。

“对于大型容器而言,hash_map能够提供比map快5至10倍的元素查找速度是很常见的,尤其是在查找速度特别重要的地方.另一方面,如果hash_map选择了病态的散列函数,他也可能比map慢得多.“

hash table(包括hash_map)并没有被列入标准之中，虽然它理应在C++标准之中占有一席之地。
虽然，现在的大多数编译平台支持hash table，但从可移植性方面考虑，还是不用hash table的好。

---

此段来源：http://www.cnblogs.com/sharpfeng/archive/2012/09/18/2691096.html

1.有的时候vector可以替代map
比如key是整数，就可以以key的跨度作为长度来定义vector。
数据规模很大的时候，差异是惊人的。当然，空间浪费往往也惊人。
2.hash是很难的东西
没有高效低碰撞的算法，hash_xxx没有意义。
而对不同的类型，数据集，不可能有优良的神仙算法。必须因场合而宜。
俺有的解决方法是GP，可不是饭型，是遗传编程，收效不错。

你的百万级的数据放到vector不大合适。因为vector需要连续的内存空间，显然在初始化这个容器的时候会花费很大的容量。
使用map，你想好了要为其建立一个主键吗？如果没有这样的需求，为什么不考虑deque或者list？
map默认使用的是deque作为容器。其实map不是容器，拿它与容器比较意义不大。因为你可以配置它的底层容器类型。

如果内存不是考虑的问题。用vector比map好。map每插入一个数据，都要排序一次。所以速度反不及先安插所有元素，再进行排序。

用 binary_search对已序区间搜索，如果是随机存取iterator，则是对数复杂度。可见，在不考虑内存问题的情况下，vector比map 好。

如果你需要在数据中间进行插入，list 是最好的选择，vector 的插入效率会让你痛苦得想死。

涉及到查找的话用map比较好，因为map的内部数据结构用rb-tree实现，而用vector你只能用线性查找，效率很低。

stl还提供了 hash容器，理论上查找是飞快~~~。做有序插入的话vector是噩梦，map则保证肯定是按key排序的，list要自己做些事情。

HASH类型的查找肯定快，是映射关系嘛，但是插入和删除却慢，要做移动操作,
LIST类型的使链式关系，插入非常快，但是查找却费时，需要遍历~~ , 还是用LIST类型的吧，虽然查找慢点，先快速排序，然后二分查找，效率也不低

---

1.3 hash_map原理

hash_map基于hash table（哈希表）。 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。

其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。

但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。 总的来说，“直接定址”与“解决冲突”是哈希表的两大特点。
hash_map，首先分配一大片内存，形成许多桶。是利用hash函数，对key进行映射到不同区域（桶）进行保存。其插入过程是：

得到key
通过hash函数得到hash值
得到桶号(一般都为hash值对桶数求模)
存放key和value在桶内。
其取值过程是:

得到key
通过hash函数得到hash值
得到桶号(一般都为hash值对桶数求模)
比较桶的内部元素是否与key相等，若都不相等，则没有找到。
取出相等的记录的value。

---

1.4 boost::unordered_map与 stl::map 区别。

stl::map是按照operator<比较判断元素是否相同，以及比较元素的大小，然后选择合适的位置插入到树中。所以，如果对map进行遍历（中序遍历）的话，输出的结果是有序的。顺序就是按照operator< 定义的大小排序。
而boost::unordered_map是计算元素的Hash值，根据Hash值判断元素是否相同。所以，对unordered_map进行遍历，结果是无序的。

用法的区别就是，stl::map 的key需要定义operator< 。 而boost::unordered_map需要定义hash_value函数并且重载operator==。对于内置类型，如string，这些都不用操心。对于自定义的类型做key，就需要自己重载operator< 或者hash_value()了。

最后，当不需要结果排好序时，最好用unordered_map。

---

此段来源：http://blog.csdn.net/u013195320/article/details/23046305

1.5 C++中map、hash_map、unordered_map、unordered_set通俗辨析

标题中提到的四种容器，对于概念不清的人来说，经常容易弄混淆。这里我不去把库里面复杂的原码拿出剖析，这个如果有兴趣其实完全可以查C++Reference,网上的原码是最权威和细致的了，而且我觉得有耐心直接认真看原码的人，也不需要我这篇速记博文了，所以我这里还是讲的通俗一些，把它们区分的七七八八。

一、hash_map、unordered_map

这两个的内部结构都是采用哈希表来实现。区别在哪里？unordered_map在C++11的时候被引入标准库了，而hash_map没有，所以建议还是使用unordered_map比较好。

哈希表的好处是什么？查询平均时间是O(1)。顾名思义，unordered，就是无序了，数据是按散列函数插入到槽里面去的，数据之间无顺序可言，但是有些时候我只要访问而不需要顺序，因此可以选择哈希表。举个最好的例子，就是我的LeetCode的博文里——Longest Consecutive Sequence这一题，我的方法二就是用的unordered_map来实现“空间弥补时间”这样的做法。

二、unordered_map与map

虽然都是map，但是内部结构大大的不同哎，map的内部结构是R-B-tree来实现的，所以保证了一个稳定的动态操作时间，查询、插入、删除都是O（logN），最坏和平均都是。而unordered_map如前所述，是哈希表。顺便提一下，哈希表的查询时间虽然是O（1），但是并不是unordered_map查询时间一定比map短，因为实际情况中还要考虑到数据量，而且unordered_map的hash函数的构造速度也没那么快，所以不能一概而论，应该具体情况具体分析。

三、unordered_map与unordered_set

后者就是在哈希表插入value，而这个value就是它自己的key，而不是像之前的unordered_map那样有键-值对，这里单纯就是为了方便查询这些值。我在Longest Consecutive Sequence这一题，我的方法一就是用了unordered_set，同样是一个将空间弥补时间的方法。再举个大家好懂的例子，给你A,B两组数，由整数组成，然后把B中在A中出现的数字取出来，要求用线性时间完成。很明显，这道题应该将A的数放到一个表格，然后线性扫描B，发现存在的就取出。可是A的范围太大，你不可能做一个包含所有整数的表，因为这个域太大了，所以我们就用unordered_set来存放A的数，具体实现库函数已经帮你搞定了，如果对于具体怎么去散列的同学又兴趣可以查看《算法导论》的第11章或者《数据结构与算法分析》的第五章，如果要看《算法导论》的同学我给个建议，完全散列你第一遍的时候可以暂时跳过不看，确实有点复杂。