leetcode 两数之和 java c++map unordered_map HashMap iterator keySet entrySet

Input: nums = [2,7,11,15], target = 9
Output: [0,1]

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //hashmap key存储数组值，value存数组下标 存储数组 然后目标数减去
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        //定义一个数组用来输出
        int[] out = new int[2];
        for(int i=0; i<nums.length;i++){         
            int t=target - nums[i];
            if(map.containsKey(t) && map.get(t) != i){
                out[0]=map.get(t);
                out[1]=i;
                break;
            }
            map.put(nums[i],i);          
        }
        return out;    
    }
}

```cpp
class Solution{
 public: 
 //vector是向量类型，可以容纳许多类型的数据，因此也被称为容器(可以理解为动态数组，是封装好了的类）
    vector<int> twoSum(vector<int>& nums,int target){
      unordered_map<int,int> m;
      vector<int> res;
       for (int i = 0; i < nums.size(); ++i) {
            m[nums[i]] = i;
        }
        for (int i = 0; i < nums.size(); ++i) {
            int t = target - nums[i];
            if (m.count(t) && m[t] != i) {
                res.push_back(i);
                res.push_back(m[t]);
                break;
            }
        }
        return res;  
    }

};

java中map
HashMap:哈希表无序 
LinkedHashMap: hashmap的子类 ，链表+哈希表 有序

```cpp
Map<int,String> map = new HashMap<int, String>();
map.put(1,"value1");
map.put(2,"value2");
System.out.println(map); // {1=value1,2=value2

//key值获取value 
map.get(1);//value1

//通过元素获取键值  keySet() key值唯一放在 set中，map.get(key) 获取value
Set<int> keySet = map.keySet();
//遍历set 得到key
Iterator<int> it = keySet.itetator();
//Iterator<int> it = map.keySet().iterator();
while(it.hasNext()){
   //得到key
   int key = it.next();
   String value= map.get(key);   
}
//增强for 循环
for (int key :map.keySet()){
   String value = map.get(key);
}

//集合遍历 entrySet
Set<Map.Entry<int,String>> entrySet = map.entrySet();
//遍历set
Iterator<Map.Entry<Sint,String>> it= entrySet.iterator();
while(it.hashNext()){
  //一对一
  Map.Entry<int,String> entry = it.next();
  //通过每一对对应关系获取对应的key
  int key = entry.getKey();
  //通过每一对对应关系获取对应的value
  String value = entry.getValue();
}

//增强
for (Entry<int,String> entry : map.entrySet()){
int key=entry.getKey();
String value =entry.getValue();
}

c++ 中 map 和unordered_map：
map:平衡二叉树 左子树小于根节点，右子树大于根节点 有序 时间复杂度 lgn
unordered_map:哈希表，无序 时间复杂度 o(1)
c++ unordered_map:

unordered_map<int,string> umap = {{1,"vaule1"},{2,"value2"}};
umap[3]="values";//有值覆盖，没值插入
umap.insert(pair<int,string>(4,"value4")); //insert pair 插入

//迭代器遍历
auto iter = umap.begin;//auto自动识别为迭代器类型unordered_map<int,string>::iterator
while(iter!= umap.end()){
  cout  << iter->first << ","<<iter.sencond << endl;
  ++iter;
}
//查找
auto find=umap.find(2);
	if(find != umap.end()){
	cout << find->first <<','<<find->sendcond<<endl;
	system("pause"）;
	return 0;
}