哈希表相关题目-leetcode简单

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

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

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

 不能使用双指针方法，因为数组是无序的；虽然可以对数组排序，但是排序后的数组索引位置改变，而本题需要返回索引位置。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        sort(nums.begin(), nums.end()); //排序后索引位置就变了
        int f=0,b=nums.size()-1;
        while(f<b){
            if(nums[f]+nums[b]==target){
                return vector<int>{f,b};
            }else if(nums[f]+nums[b]>target){
                b--;
            }else{
                f++;
            }
        }
        return res;
    }
};

方法一、暴力方法 

遍历每个元素 xx，并查找是否存在一个值与 target - xtarget−x 相等的目标元素。时间复杂度：O(n^2)。

方法二、两遍哈希表

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素（target - nums[i]）是否存在于表中。注意，该目标元素不能是 nums[i]本身！时间复杂度：O(n)

//[3,3] 时不通过
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //vector<int> res;
        map<int,int> maps;
        int n=nums.size();
        for(int i=0;i<n;i++){
            maps.insert(make_pair(nums[i],i));   //maps.insert(make_pair<int,int>(nums[i],i)); // not ok    
            //maps[nums[i]]=i;  //ok
        }
        for(int i=0;i<n-1;i++){  //此处是n-1
            int tar = target-nums[i];
            if(maps.find(tar)!=maps.end() && maps[tar]!=i)
                //return vector<int>(i,maps[tar]); //错误写法
                //return {i,maps[tar]}; //ok
                return vector<int>{i,maps[tar]}; 
        }
        return {};
    }
};

//make_pair 后买你不需要加类型
//注意区分map与unorder_map

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int sz = nums.size();
        vector<int> res;
        if(sz<2)
            return res;
        
        map<int,int> m;
        for(int i=0;i<sz;i++){
            m[nums[i]]=i;
        }
        
        for(int i=0;i<sz-1;i++){
            if(m.find(target-nums[i]) != m.end() && m[target-nums[i]]!=i){
                res.push_back(i);
                res.push_back(m[target-nums[i]]);
                break;
            }      
        }
        return res;
    }
};

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> m;
        for (int i = 0; i < nums.size(); ++i) {
            if (m.count(target - nums[i])) {
                return {i, m[target - nums[i]]};
            }
            m[nums[i]] = i;
        }
        return {};
    }
};

136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

使用异或的方法

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res=0;
        for(int i=0;i<nums.size();i++){
            res = res^nums[i];     
        }
        return res;
    }
};

哈希算法

• 若第一次出现，插入哈希集
• 第二次出现，冲哈希集内删除
• 最后剩下的就是那个只出现一次的数字

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        unordered_set<int> s;
        for(int i=0;i<nums.size();i++){
            if(s.count(nums[i]))
                s.erase(nums[i]);
            else
                s.insert(nums[i]);
            
        }
        int res;
        for(auto i : s)
            res = i;
        
        return res;
    }
};

202. 快乐数

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

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

输入: 19
输出: true
解释: 
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

　　

；