leetcode_哈希表

丶夜未央丶

已于 2023-04-28 12:48:31 修改

阅读量71

点赞数

分类专栏： leetcode 文章标签： leetcode 散列表算法

于 2023-01-04 16:25:05 首次发布

本文链接：https://blog.csdn.net/zhsmkxy/article/details/128521571

版权

leetcode 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

哈希表

242.有效的字母异位词
349.两个数组的交集
202.快乐数
454.四数相加II
15.三数之和
18.四数之和
总结
手写哈希表

242.有效的字母异位词

力扣题目链接

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length()!=t.length())
        {
            return false;
        }
        int records[26] = {0};
        for(auto s1:s)
        {
            records[s1-'a']++;
        }
        for(auto s1:t)
        {
            records[s1-'a']--;
        }
        for(int i =0;i<26;i++)
        {
            if(records[i]!=0)
            {
                return false;
            }
        }
        return true;
    }
};

349.两个数组的交集

力扣题目链接

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set1;
        unordered_set<int> set2;
        vector<int> ans;
        for(int i =0;i<nums1.size();i++)
        {
            set1.insert(nums1[i]);
        }
        for(int i =0;i<nums2.size();i++)
        {
            set2.insert(nums2[i]);
        }
        for(auto iter=set1.begin();iter!=set2.end();++iter)
        {
            if(set1.count(*iter)==set2.count(*iter))
            {
                ans.push_back(*iter);
            }
        }
        return ans;
    }
};

202.快乐数

解法1：set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set1;
        unordered_set<int> set2;
        vector<int> ans;
        for(int i =0;i<nums1.size();i++)
        {
            set1.insert(nums1[i]);
        }
        for(int i =0;i<nums2.size();i++)
        {
            set2.insert(nums2[i]);
        }
        for(auto iter=set1.begin();iter!=set2.end();++iter)
        {
            if(set1.count(*iter)==set2.count(*iter))
            {
                ans.push_back(*iter);
            }
        }
        return ans;
    }

};

解法2：map

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> map;
        vector<int> ans;
        for (int i = 0; i < nums.size(); i++)
        {
            auto iter = map.find(target - nums[i]);
            if (iter != map.end())
            {
                ans.push_back(i);
                ans.push_back(iter->second);
            }
            else
            {
                map.insert({ nums[i],i });
            }
        }
        return ans;
    }
};

454.四数相加II

力扣题目链接

在unordered_map使用中，对于原来不存在的<key,value>，可以直接赋值，例如umap[num1+num2]++,umap[num1+num2]在没有++之前默认为0，所以就不需要写一个if else判断元素是否在umap中，如果不存在赋值1，如果存在赋值++了。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        int count=0;
        for (auto num1 : nums1)
        {
            for (auto num2 : nums2)
            {
                umap[num1 + num2]++;
            }
        }
        for (auto num3 : nums3)
        {
            for (auto num4 : nums4)
            {
                if (umap.find(0 - num3 - num4) != umap.end())
                {
                    count += umap[0 - num3 - num4];
                }
            }
        }
        return count;
    }
};

15.三数之和

关于a的去重，我自己在写的时候，虽然看出了不能仅仅依靠nums[i]==nums[i+1]去判断，这样会丢失一些情况，但我的判断条件写成了
if(nums[i]==nums[i+1]&&nums[i+1]==nums[i+2]) 针对的是出现[0,0,0,0]的情况。a的去重还是要考虑最一般的问题，如果出现前后两个重复了，还是要去一个。所以问题就转换成判断nums[i]==nums[i+1],还是i>0&&nums[i]==nums[i-1]。答案是后者，前者的话会丢失三元组内部元素可以重复的情况，比如（-1，-1，2）这样。关于b和c的去重，要在得到一个符合情况的三元组时去重，这个去重的位置是我没有想到的，仔细琢磨之后还是可以想通的，三数之和，梦破碎的地方，名不虚传。

代码随想录(三数之和)

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return result;
            }
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                if (nums[i] + nums[left] + nums[right] > 0) right--;
                else if (nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

18.四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int> > res;
        //四数之和使用两层for循环带着left和right双指针
        for (int i = 0; i < nums.size(); i++)
        {
            //与三数之和不同的是剪枝的条件：当nums[i]>target时，如果target<0,nums[i]<0,此时依然存在符合的条件
            //例如[-4,-3,-2,-1],target=-10,原因在于两个小于0的数相加可以得到更小的数
            //所以剪枝的条件不要忘记，此时nums[i]>=0才可以
            if (nums[i] > target && nums[i] >= 0) break;
            //a去重的条件并不改变
            if (i>0 && nums[i] == nums[i - 1]) continue;
            for (int j = i + 1; j < nums.size(); j++)
            {
                //剪枝的条件的思路跟一个数是一样的
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0)break;
                //b去重的条件并不改变
                if (j > i + 1 && nums[j] == nums[j - 1])continue;
                int left = j + 1, right = nums.size() - 1;
                while (right > left)
                {
                    
                    if ((long)nums[i] + nums[j] + nums[left] + nums[right] > target)right--;
                    else if ((long)nums[i] + nums[j] + nums[left] + nums[right] < target)left++;
                    else{
                        //c和d去重的条件不改变
                        res.push_back({ nums[i],nums[j],nums[left],nums[right] });
                        while (right > left && nums[left] == nums[left + 1])left++;
                        while (right > left && nums[right] == nums[right - 1])right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};

总结

代码随想录总结

手写哈希表

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+3; //大于10w的第一个质数
//拉链法(开散列) 存储hash表
struct NODE{
	int val,next;
}node[N];
int h[N],idx;

int F(int x){
	int k = x; //具体实现的时候哈希函数可以自定义
	return k;
}

void insert(int x){
	int k = F(x);
	node[idx].val = x;
	node[idx].next = h[k];
	h[k] = idx;
	idx++;
}

bool find(int x){
	int k = F(x);
	for(int i =h[k];i!=-1;i=node[i].next)
		if(node[i].val==x)
			return true;
	return false;
}

int main(){
	memset(h,-1,sizeof(h));
	int n;
	cin>>n;
	while(n--){
		char op;
		int x;
		cin>>op>>x;
		if(op=='1') insert(x);
		else{
			if(find(x)) cout<<"Yes"<<endl;
			else cout<<"No"<<endl;
		}
	}
	return 0;
}