1. 两数之和 599. 两个列表的最小索引总和 219. 存在重复元素 II 10.29补

两数之和

解法

c++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //创建一个map的哈希表，第一个存数值，第二个存位置
        unordered_map<int,int> hashtable;
        for(int i =0;i<nums.size();++i){
            //find是找键值
            auto it= hashtable.find(target-nums[i]);
            if (it !=hashtable.end()){
                // 找到了匹配的元素，可以访问元素值
                return {it->second,i};
            }else{
                //如果没有找到匹配的元素,就往里面存键值对
                hashtable[nums[i]]=i;
            }}
return {};
        }
    
};

python

#暴力的两次循环法
class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        #写一个数组长度
        l_n=len(nums)
        #创建一个字典
        a=dict()
        for i in range(l_n):
            for j in range(i+1,l_n):
                if nums[j] ==target-nums[i]:
                #键存第一个数位置，值存第二个数位置
                    a[i]=j
        print(a)
        return([a.keys()[0],a.values()[0]])
       

219. 存在重复元素 II

解法

建立一个字典，键是元素，值是元素位置。
使用enumerate函数遍历数组

python

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        a=dict()
        #i是数组的元素位置，num是数组的元素
        for i,num in enumerate(nums):
        #如果num在字典的键里，i-j<=k,则返回true
            if num in a and i-a[num]<=k:
                return True
            a[num]=i
        return False    

c++

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int,int> hash;
        for (int i=0;i<nums.size();++i){
            if( hash.count(nums[i]) && i-hash[nums[i]]<=k  ){
                return true;
            }
            //填充哈希表元素
            hash[nums[i]]=i;
        }
        return false;

    }
};

599. 两个列表的最小索引总和

解法

python

#自己写的
class Solution:
    def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
        #两个hash表
        #a1存list1,a2存两个列表的重复元素还有两元素的索引和
        a1=dict()
        a2=dict()
        #a列表存放两个列表中重复元素的索引和，以便之后找最小索引和
        a=list()
        for i,num in enumerate(list1):
            a1[num]=i
        for i,num in  enumerate(list2):
            if num in a1:
                a2[num]=abs(i+a1[num])
                a.append(a2[num])
        b=[key for key,value in a2.items() if value==min(a)]
        return b

c++

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
        unordered_map<string,int> hash;
        for(int i=0;i<list1.size();i++){
            hash[list1[i]]=i;
        }
        //存放索引最小的字符串数组
        vector<string> res;
        //INT_MAX 是一个整数常量，通常用于表示整数的最大可能值
        int IndexMin=INT_MAX;
        for(int i=0;i<list2.size();++i){
             if (hash.count(list2[i])){

                 if (hash[list2[i]]+i<IndexMin){
                     res.clear();
                     res.push_back(list2[i]);
                     IndexMin=hash[list2[i]]+i;
                 }else if(hash[list2[i]]+i==IndexMin){
                     res.push_back(list2[i]);
                 }
             }
        }
        return res;

    }
};