代码随想录算法day5

理论解法均摘自代码随想录

个人总结

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
• 另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

哈希表理论基础

#哈希表

首先什么是哈希表，哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表，大家看到这两个名称知道都是指hash table就可以了）。

哈希表是根据关键码的值而直接进行访问的数据结构。

这么官方的解释可能有点懵，其实直白来讲其实数组就是一张哈希表。

哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示：

那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。

例如要查询一个名字是否在这所学校里。

要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。

我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。

将学生姓名映射到哈希表上就涉及到了hash function ，也就是哈希函数。

#哈希函数

哈希函数，把学生的姓名直接映射为哈希表上的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里了。

哈希函数如下图所示，通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射为哈希表上的索引数字了。

如果hashCode得到的数值大于 哈希表的大小了，也就是大于tableSize了，怎么办呢？

此时为了保证映射出来的索引数值都落在哈希表上，我们会在再次对数值做一个取模的操作，这样我们就保证了学生姓名一定可以映射到哈希表上了。

此时问题又来了，哈希表我们刚刚说过，就是一个数组。

如果学生的数量大于哈希表的大小怎么办，此时就算哈希函数计算的再均匀，也避免不了会有几位学生的名字同时映射到哈希表 同一个索引下标的位置。

接下来哈希碰撞登场

#哈希碰撞

如图所示，小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。

一般哈希碰撞有两种解决方法， 拉链法和线性探测法。

#拉链法

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了

（数据规模是dataSize， 哈希表的大小为tableSize）

其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。

#线性探测法

使用线性探测法，一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

其实关于哈希碰撞还有非常多的细节，感兴趣的同学可以再好好研究一下，这里我就不再赘述了。

#常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

• 数组
• set （集合）
• map(映射)

这里数组就没啥可说的了，我们来看一下set。

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

其他语言例如：java里的HashMap ，TreeMap 都是一样的原理。可以灵活贯通。

虽然std::set和std::multiset 的底层实现基于红黑树而非哈希表，它们通过红黑树来索引和存储数据。不过给我们的使用方式，还是哈希法的使用方式，即依靠键（key）来访问值（value）。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。std::map也是一样的道理。

这里在说一下，一些C++的经典书籍上 例如STL源码剖析，说到了hash_set hash_map，这个与unordered_set，unordered_map又有什么关系呢？

实际上功能都是一样一样的， 但是unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，hash_set，hash_map 是C++11标准之前民间高手自发造的轮子。

#总结

总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！

gpt

哈希表（Hash Table）是一种高效的数据结构，它能够在平均情况下以 O(1) 的时间复杂度完成插入、删除和查找操作。哈希表的核心概念包括哈希函数、数组和处理冲突的方法。以下是关于哈希表以及与之相关的数据结构（数组、集合（Set）和映射（Map））的一些理论基础。

哈希表的概念

• 哈希函数：哈希函数（Hash Function）是一种将输入映射到固定大小的哈希值（Hash Value）的函数。理想的哈希函数能够高效地将不同的输入映射到不同的哈希值上，从而减小冲突的概率。
• 冲突（Collision）：由于哈希函数的输出空间有限，可能会有不同的输入映射到相同的哈希值，这种情况称为冲突。处理冲突的方法有多种，包括链地址法（Separate Chaining）和开放地址法（Open Addressing）等。

数组

• **数组（Array）**是一种线性数据结构，它使用一连续的内存块来存储元素。每个元素都可以通过其索引快速访问，访问时间复杂度为 O(1)。
• 在哈希表中，哈希值通常用作数组的下标，从而使得能够快速定位存储位置。

集合（Set）

• **集合（Set）**是一种不允许重复元素的数据结构。它的主要操作包括插入元素、删除元素和检查元素是否存在。
• 哈希表常用于实现集合，因为它能够在常数时间内完成这些操作。

映射（Map）

• 映射（Map），也称为字典（Dictionary），是一种存储键值对的集合，其中每个键（Key）是唯一的，键与值（Value）相关联。
• 哈希表也是实现映射的一种常用数据结构，因为它能够高效地通过键访问对应的值。

哈希表的实现

1. 哈希函数设计：选择一个合适的哈希函数，使得哈希值均匀分布，减少冲突发生的概率。
2. 处理冲突的方法：
   • 链地址法（Separate Chaining）：每个数组元素除了存储值本身外，还维护一个链表（或其他数据结构）来存储哈希冲突的元素。

     cpp

     复制代码

     struct Node {
         int key;
         int value;
         Node* next;
     };
     Node* hashTable[SIZE];
     

   • 开放地址法（Open Addressing）：当冲突发生时，通过探测（如线性探测、二次探测）来寻找下一个空闲的位置。

     cpp

     复制代码

     int hashTable[SIZE];
     bool isOccupied[SIZE]; // 记录每个位置是否被占用
     

示例代码

下面是一个简单的哈希表实现示例（以C++为例）：

cpp

复制代码

#include <iostream>
#include <list>
#include <vector>

class HashTable {
private:
    std::vector<std::list<int>> table;
    int size;

    int hashFunction(int key) {
        return key % size;
    }

public:
    HashTable(int size) : size(size) {
        table.resize(size);
    }

    void insert(int key) {
        int index = hashFunction(key);
        table[index].push_back(key);
    }

    void remove(int key) {
        int index = hashFunction(key);
        table[index].remove(key);
    }

    bool search(int key) {
        int index = hashFunction(key);
        for (int item : table[index]) {
           if (item == key) return true;
        }
        return false;
    }
};

int main() {
    HashTable hashTable(10);
    hashTable.insert(5);
    hashTable.insert(15);
    hashTable.insert(25);
    if (hashTable.search(15)) {
        std::cout << "Found 15" << std::endl;
    } else {
        std::cout << "15 not found" << std::endl;
    }
    hashTable.remove(15);
    if (hashTable.search(15)) {
        std::cout << "Found 15" << std::endl;
    } else {
        std::cout << "15 not found" << std::endl;
    }
    return 0;
}

以上代码示例是一个基于链地址法的哈希表，可以插入、删除和查找整数键。

242.有效的字母异位词

力扣题目链接(opens new window)

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

思路

先看暴力的解法，两层for循环，同时还要记录字符是否重复出现，很明显时间复杂度是 O(n^2)。

暴力的方法这里就不做介绍了，直接看一下有没有更优的方式。

数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。

如果对哈希表的理论基础关于数组，set，map不了解的话可以看这篇：关于哈希表，你该了解这些！(opens new window)

需要定义一个多大的数组呢，定一个数组叫做record，大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII也是26个连续的数值。

为了方便举例，判断一下字符串s= "aee", t = "eae"。

操作动画如下：

定义一个数组叫做record用来上记录字符串s里字符出现的次数。

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)。

C++ 代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

 建立数组

int[] record = new int[26];

class Solution {
    public boolean isAnagram(String s, String t) {
        int len_s=s.length();
        int len_t=t.length();
        if (len_s!=len_t){
            return false;
        }
        int[] record=new int[26];//26字母
        for(int i=0;i<len_s;i++){
            record[s.charAt(i)-'a']++;
        }
        for(int i=0;i<len_t;i++){
            record[t.charAt(i)-'a']--;
        } 
        for(int n:record){
            if (n!=0){
                return false;//不能对应删掉，输出false
            }
        }
        return true;
    }
}

349. 两个数组的交集

力扣题目链接(opens new window)

题意：给定两个数组，编写一个函数来计算它们的交集。

说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

#算法公开课

《代码随想录》算法视频公开课 (opens new window)：：学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集 (opens new window)，相信结合视频再看本篇题解，更有助于大家对本题的理解。

#思路

这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序

这道题用暴力的解法时间复杂度是O(n^2)，那来看看使用哈希法进一步优化。

那么用数组来做哈希表也是不错的选择，例如242. 有效的字母异位词(opens new window)

但是要注意，使用数组来做哈希的题目，是因为题目都限制了数值的大小。

而这道题目没有限制数值的大小，就无法使用数组来做哈希表了。

而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

思路如图所示：

C++代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

• 时间复杂度: O(n + m) m 是最后要把 set转成vector
• 空间复杂度: O(n)

#拓展

那有同学可能问了，遇到哈希问题我直接都用set不就得了，用什么数组啊。

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

#后记

本题后面 力扣改了 题目描述 和 后台测试数据，增添了 数值范围：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

对应C++代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

• 时间复杂度: O(m + n)
• 空间复杂度: O(n)

java set

Set<Integer> set1 = new HashSet<>(); 是 Java 中创建一个 HashSet 的声明和初始化语句。这个 Set 代表一个不允许重复元素的集合，而且没有顺序的保证。下面我们将详细解释其中的概念和用法。

Set 和 HashSet

• Set：Set 是 Java 集合框架中的一个接口，它表示一个不包含重复元素的集合。接口在 java.util 包中定义。下面是 Set 和 Collection 接口的一些关键方法：

  java

  复制代码

  public interface Set<E> extends Collection<E> {
      int size();
      boolean isEmpty();
      boolean contains(Object o);
      Iterator<E> iterator();
      boolean add(E e);
      boolean remove(Object o);
      void clear();
      // 其他方法从 Collection 继承
  }
  

• HashSet：HashSet 是 Set 接口的具体实现类之一。它利用哈希表（实际上是 HashMap）来存储元素，不保证元素的插入顺序。因为使用了哈希表，操作的平均时间复杂度为 O(1)，包括插入、删除和查找操作。

  java

  复制代码

  public class HashSet<E> extends AbstractSet<E>
      implements Set<E>, Cloneable, java.io.Serializable {
      // 底层存储是 HashMap
      private transient HashMap<E,Object> map;
      // 在背后，所有元素都存储作为 HashMap 的键
  }
  

示例代码

以下是使用 Set 和 HashSet 的示例代码，这些代码展示了如何添加、删除和检查元素，以及如何遍历集合。

java

复制代码

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        // 创建一个 HashSet，存储 Integer 类型的元素
        Set<Integer> set1 = new HashSet<>();

        // 向集合添加元素
        set1.add(1);
        set1.add(2);
        set1.add(3);
        set1.add(1);  // 重复元素，不会被添加

        // 检查集合是否包含某个元素
        if (set1.contains(2)) {
            System.out.println("Set contains 2");
        }

        // 移除元素
        set1.remove(2);

        // 遍历集合
        for (Integer number : set1) {
            System.out.println(number);
        }

        // 检查集合的大小
        System.out.println("Set size: " + set1.size());

        // 清空集合
        set1.clear();
        System.out.println("Is set empty? " + set1.isEmpty());
    }
}

运行结果

plaintext

复制代码

Set contains 2
1
3
Set size: 2
Is set empty? true

解释

1. 创建集合： Set<Integer> set1 = new HashSet<>(); 初始化了一个空的 HashSet，该集合可以存储 Integer 类型的元素。
2. 添加元素： set1.add(1); 添加元素 1 到集合中。重复的元素（如 1 再次添加）不会重复存储。
3. 检查元素： set1.contains(2); 返回 true 如果元素存在，否则返回 false。
4. 移除元素： set1.remove(2); 从集合中移除元素 2，如果它存在。
5. 遍历集合： 使用 for-each 循环遍历集合中的元素。
6. 集合大小： set1.size(); 返回集合中的元素个数。
7. 清空集合： set1.clear(); 删除集合中所有的元素，并且 isEmpty() 将返回 true。

总结

Set<Integer> set1 = new HashSet<>(); 创建了一个 HashSet，该集合不允许重复元素且没有顺序保证。操作这些集合的方法包括添加、删除、检查元素以及遍历集合等。由于基于哈希表，HashSet 提供了高效的性能。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //hash 储存
        Set<Integer> set1=new HashSet<>();//hashset构建
        Set<Integer> resSet=new HashSet<>();
        for(int i:nums1){
            set1.add(i);
        }
        for(int j:nums2){
            if(set1.contains(j)){
                resSet.add(j);
            }
        }
        //转换成数组
        int[] result=new int[resSet.size()];//数组的构建
        int m=0;
        for (int k:resSet){
            result[m++]=k;
        }
        return result;
    }
}

第202题. 快乐数

力扣题目链接(opens new window)

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

#思路

这道题目看上去貌似一道数学问题，其实并不是！

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

正如：关于哈希表，你该了解这些！ (opens new window)中所说，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。

还有一个难点就是求和的过程，如果对取数值各个位上的单数操作不熟悉的话，做这道题也会比较艰难。

首先解释问题背景：为什么 sum 出现过就表明开始循环了？

在判断一个数是否是快乐数的过程中，每次都将当前数替换为其每个位置上的数字的平方和。假如这个过程导致当前数重复出现，这意味着我们陷入了一个循环，因为从那个数开始将重复之前的所有步骤，不可能再逃出这个循环。所以，如果 sum 出现过说明已经是无解的局面，导致一个数字重复出现，即是无限循环，这表示该数字无法到达 1，因此它不是一个快乐数。

//找一个曾经出现过的数，用hash

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set=new HashSet<>();
        int sum=getsum(n);//先算n的
        while(sum!=1){
            //计算和
            set.add(sum);
            sum=getsum(sum);//后面循环的是sum

            //重复就停止循环
            if(set.contains(sum)){
                return false;
            }

        }
        return true;

    }

    private int getsum(int n){
        int sum=0;
        while(n>0){
                int temp=n%10;
                sum+=temp*temp;
                n=n/10;
            }
        return sum;
    }
}

本题还有双指针算法

1. 两数之和

力扣题目链接(opens new window)

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

#算法公开课

《代码随想录》算法视频公开课 (opens new window)：梦开始的地方，Leetcode：1.两数之和 (opens new window),相信结合视频再看本篇题解，更有助于大家对本题的理解。

#思路

很明显暴力的解法是两层for循环查找，时间复杂度是O(n^2)。

建议大家做这道题目之前，先做一下这两道

• 242. 有效的字母异位词(opens new window)
• 349. 两个数组的交集(opens new window)

242. 有效的字母异位词 (opens new window)这道题目是用数组作为哈希表来解决哈希问题，349. 两个数组的交集 (opens new window)这道题目是通过set作为哈希表来解决哈希问题。

首先我再强调一下 什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。

那么我们就应该想到使用哈希法了。

因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

再来看一下使用数组和set来做哈希法的局限。

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

C++中map，有三种类型：

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(log n)	O(log n)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。

同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。 更多哈希表的理论知识请看关于哈希表，你该了解这些！ (opens new window)。

这道题目中并不需要key有序，选择std::unordered_map 效率更高！ 使用其他语言的录友注意了解一下自己所用语言的数据结构就行。

接下来需要明确两点：

• map用来做什么
• map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

过程如下：

C++代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 时间复杂度: O(n)
• 空间复杂度: O(n)

#总结

本题其实有四个重点：

• 为什么会想到用哈希表
• 哈希表为什么用map
• 本题map是用来存什么的
• map中的key和value用来存什么的

把这四点想清楚了，本题才算是理解透彻了。

很多录友把这道题目 通过了，但都没想清楚map是用来做什么的，以至于对代码的理解其实是 一知半解的。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result=new int[2];
        if(nums==null || nums.length==0){//empty
           return result;
        }
        Map<Integer,Integer> map=new HashMap<>();
        for (int i=0;i<nums.length;i++){
            int target_rev=target-nums[i];
            if (map.containsKey(target_rev)){
                result[0]=map.get(target_rev);
                result[1]=i;
                return result;
            } 
            else{
                map.put(nums[i],i);//nums[i] as key, for search
            }
        }
        return result;
    }
}