leetcode 哈希表相关算法刷题笔记

最新推荐文章于 2022-05-30 14:06:51 发布
最新推荐文章于 2022-05-30 14:06:51 发布
阅读量442 收藏 1
点赞数
分类专栏： 数据结构与算法刷题专栏 文章标签： leetcode 算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CLZHIT/article/details/122336312
版权

刷题笔记

hash table 算法leetcode专栏

leetcode 242 有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        vector<int> hashVec(26, 0);
        for(int i = 0; i < s.size(); i++)
        {
            hashVec[s[i] -'a']++;
        }
        for(int i = 0; i < t.size(); i++)
        {
            hashVec[t[i] - 'a']--;    
        }
        bool flag = true;
        for(int i = 0; i < hashVec.size(); i++)
        {
            if(hashVec[i] != 0)
            {
                flag = false;
                break;
            }
        }
        return flag;
    }
};

leetcode 383 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> hashVec(26, 0);
        for(int i = 0; i < magazine.size(); i++)
        {
            hashVec[magazine[i] -'a']++;
        }
        for(int i = 0; i < ransomNote.size(); i++)
        {
            hashVec[ransomNote[i] - 'a']--;    
        }
        bool flag = true;
        for(int i = 0; i < hashVec.size(); i++)
        {
            if(hashVec[i] < 0)
            {
                flag = false;
                break;
            }
        }
        return flag;
    }
};

leetcode 49 字母异位词分组

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {
		map<vector<int>, vector<string>> umap;
		vector<vector<string>> result;
		for (int i = 0; i < strs.size(); i++)
		{
			string str = strs[i];
			vector<int> hashVec = convertStr(str);
			if (umap.find(hashVec) == umap.end())
			{
				umap[hashVec] = vector<string>();
			}
			umap[hashVec].push_back(str);
		}
		map<vector<int>, vector<string>>::iterator it;
		for (it = umap.begin(); it != umap.end(); it++)
		{
			result.push_back(it->second);
		}
		return result;
	}
	vector<int> convertStr(string str)
	{
		vector<int> hashVec(26, 0);
		for (int i = 0; i < str.size(); i++)
		{
			hashVec[str[i] - 'a']++;
		}
		return hashVec;
	}
};

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {
		unordered_map<string, vector<string>> umap;
		vector<vector<string>> result;
		for (int i = 0; i < strs.size(); i++)
		{
			string str = strs[i];
            sort(str.begin(), str.end());
			if (umap.find(str) == umap.end())
			{
				umap[str] = vector<string>();
			}
			umap[str].push_back(strs[i]);
		}
		unordered_map<string, vector<string>>::iterator it;
		for (it = umap.begin(); it != umap.end(); it++)
		{
			result.push_back(it->second);
		}
		return result;
	}
};

leetcode 138 复制带随机指针的链表

class Solution {
public:
    Node* copyRandomList(Node* head) {
        unordered_map<Node*, int> umap;   // Node address --->  vector index
        vector<Node*> newNode;
        Node* ptr = head;
        if(!head) return NULL;
        int k = 0;
        while(ptr != NULL)
        {
            umap.insert(pair<Node*, int>(ptr, k));
            newNode.push_back(new Node(ptr->val));
            ptr = ptr->next;
            k++;
        }
        ptr = head;
        k = 0;
        newNode.push_back(NULL);   //为了在下面链接新节点的next指针不用特殊处理最后一个Node
        while(ptr != NULL)
        {
            newNode[k]->next = newNode[k+1];
            Node* tmp = ptr->random;
            if(tmp != NULL)
            {
                int id = umap[tmp];
                newNode[k]->random = newNode[id]; 
            }
            else
            {
                newNode[k]->random = NULL;
            }
            ptr = ptr->next;
            k++;
        }
        return newNode[0];
    }
};

leetcode 1002 查找共用字符

class Solution {
public:
    vector<string> commonChars(vector<string>& words) {
        vector<int> hashVec(26, 0);
        for(int i = 0; i < words[0].size(); i++)
        {
            hashVec[words[0][i] - 'a']++;
        }
        int hashOtherStr[26] = {0};
        for(int i = 1; i < words.size(); i++)
        {
            memset(hashOtherStr, 0, 26 * sizeof(int));   //别忘了恢复hashOtherStr的状态
            for(int j = 0; j < words[i].size(); j++)
            {
                hashOtherStr[words[i][j] - 'a']++;
            }
            for(int k = 0; k < 26; k++)
            {
                hashVec[k] = hashVec[k] < hashOtherStr[k] ? hashVec[k] : hashOtherStr[k];
            }
        }
        vector<string> result;
        for(int k = 0; k < 26; k++)
        {
            while(hashVec[k])
            {
                string s(1, k + 'a');   //char -- string
                result.push_back(s);
                hashVec[k]--;
            }
        }
        return result;
    }
};

leetcode 349 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> tmpSet;
        unordered_set<int> uset(nums1.begin(), nums1.end());
        for(int i = 0; i < nums2.size(); i++)
        {
            if(uset.find(nums2[i]) != uset.end())
            {
                tmpSet.insert(nums2[i]);
            }
        }
        vector<int> result(tmpSet.begin(), tmpSet.end());
        return result;
    }
};

leetcode 350 两个数组的交集II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;
        unordered_map<int, int> umap;
        for(auto ele : nums1)
        {
            umap[ele]++;
        }
        for(auto ele : nums2)
        {
            if(umap[ele] > 0)
            {
                result.push_back(ele);
                umap[ele]--;
            }
        }
        return result;
    }
};

leetcode 202 快乐数

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> uset;
        while(1)
        {
            int sum = getSum(n);
            if(sum == 1)
            {
                return true;
            }
            else
            {
                if(uset.find(sum) != uset.end())
                {
                    return false;
                }
                uset.insert(sum);
                n = sum;
            }
        }
    }
    int getSum(int n)
    {
        int sum = 0;
        while(n)
        {
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }
};

leetcode 1 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> mp;   //key无序 key不可重复
        vector<int> result;
        for(int i = 0; i < nums.size(); i++)
        {
            auto it = mp.find(target - nums[i]);  //固定一个元素，在之前的元素集合中找另一个
            if(it != mp.end()) 
            {
                result.push_back(it->second);
                result.push_back(i);
            }
            mp.insert(pair<int, int>(nums[i], i));
        }
        return result;
    }
};

leetcode 15 三数之和

class Solution {
public:
	vector<vector<int>> threeSum(vector<int>& nums) {
		vector<vector<int>> result;
		sort(nums.begin(), nums.end());

		int size = nums.size();

		if (nums.empty() || nums.back() < 0 || nums.front() > 0)
		{
			return {};
		}

		for (int i = 0; i < size - 2; i++)
		{
			if (nums[i] > 0)
			{
				break;
			}

            if(i > 0 && nums[i] == nums[i-1])
            {
                continue;
            }

			int fix = nums[i];
			int target = 0 - fix;

			int first = i + 1;
			int last = size - 1;

			while (first < last)
			{
				if (nums[first] + nums[last] == target)
				{
					result.push_back( {nums[i], nums[first], nums[last]} );

					while (first < last && nums[first] == nums[first + 1])
					{
						first++;
					}
					while (first < last && nums[last] == nums[last - 1])
					{
						last--;
					}

					first++;
					last--;
				}
                else if (nums[first] + nums[last] < target)
				{
					first++;
				}
				else
				{
					last--;
				}
			}
		}
		return result;
	}
};

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        if(nums.size() == 0 || nums.front() > 0 || nums.back() < 0)
        {
            return result;
        }
        
        for(int i = 0; i < nums.size(); i++)
        {
            int left = i + 1;
            int right = nums.size() - 1;
            
            if(i > 0 && nums[i] == nums[i-1])
            {
                continue;
            }

            while(left < right)
            {
                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]});
                    
                    while(left < right && nums[left] == nums[left+1])  // 去重逻辑应该放在找到一个三元组之后
                    {
                        left++;  
                    }
                    while(left < right && nums[right] == nums[right-1])
                    {
                        right--;
                    }

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

leetcode 18 四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++)
        {
            if(i > 0 && nums[i] == nums[i-1])
            {
                continue;
            }
            for(int k = i + 1; k < nums.size(); k++)
            {
                if(k > i + 1 && nums[k] == nums[k-1])
                {
                    continue;
                }
                int left = k + 1;
                int right = nums.size() - 1;

                while(left < right)
                {
                    //if(nums[i] + nums[k] + nums[left] + nums[right] > target) 会溢出
                    if(nums[i] + nums[k] > target - (nums[left] + nums[right]))
                    {
                        right--;
                    }
                    else if (nums[i] + nums[k] < target - (nums[left] + nums[right]))
                    {
                        left++;
                    }
                    else
                    {
                        result.push_back(vector<int>{nums[i], nums[k], nums[left], nums[right]});
                    
                        while(left < right && nums[left] == nums[left+1])  // 去重逻辑应该放在找到一个三元组之后
                        {
                            left++;  
                        }
                        while(left < right && nums[right] == nums[right-1])
                        {
                            right--;
                        }

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

leetcode 454 四数相加II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;   // key --> a+b  value --> a+b出现的次数 
        for(auto a : nums1)
        {
            for(auto b : nums2)
            {
                umap[a+b]++;
            }
        }
        int count = 0;     //计算a+b+c+d出现的次数
        for(auto c : nums3)
        {
            for(auto d : nums4)
            {
                if(umap.find(0 - (c+d)) != umap.end())
                {
                    count += umap[0 -(c+d)];
                }
            }
        }
        return count;
    }
};
不会code的菜鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题笔记-Greedy贪婪算法
Sengo的博客
11-22 971
330.Patching Array class Solution(object): def minPatches(self, nums, n): i, far, re = 0, 0, 0 nums = sorted(nums) while far < n : if i < len(nums...
leetcode刷题笔记——贪心算法
md_Ji的博客
01-19 201
leetcode刷题笔记——贪心算法 目前完成的贪心相关的leetcode算法题序号： 中等：763 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reconstruct-itinerary 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 文章目录leetcode刷题笔记——贪心算法算法理解一、763题：划分字母区间1.题干2.思路3.代码 算法理解 顾名思义，贪心算法或贪心思想采用贪心的策略，保证每次操作都是局部最优的，从
vector 用法
08-07 290
c.clear()移除容器中所有数据。 c.empty()判断容器是否为空。 c.erase(pos)删除pos位置的数据 ...
记录一下vector基本用法（简单易懂）
hdheid的博客
03-12 5666
vector容器的初始化 vector的使用首先需要加一个头文件#include<vector>； vector<int> a; 最一般的初始化方法，就是定义一个容器啊a； vector<int>a(n); 定义一个长度为n的容器a； vector<int>a(n,x); 定义一个长度为n，每...
memset函数的使用
lianghui0811
08-01 323
void *memset(void *s, int ch, size_t n); 函数解释：将s中当前位置后面的n个字节(typedef unsigned int size_t)用 ch 替换并返回s。 memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法，总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值(非数值型字符) c。
2022.3.28（个人学习记录）
m0_58938307的博客
04-20 93
1.力扣1002 查找共用字符 memset(hashOtherStr, 0, 26 * sizeof(int)); 把hashother中所有字节(前26个字节)换做字符“0”，常用来对指针或字符串的初始化。 string s(1, i + 'a'); // char -> string string构造函数，第一个参数表示要构造的字符串长度是1。 ...
1002. 查找常用字符 leecode
weixin_30522095的博客
03-03 99
题目： 给定仅有小写字母组成的字符串数组A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。 你可以按任意顺序返回答案。 示例 1： 输入：["bella","label","roller"] 输出：["e","l","l"] 示例 2： 输入：["cool"...
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
leetcode跳跃-leetcode:leetcode刷题笔记
06-30
leetcode刷题笔记 005-2. 最长回文子串 字符串+中心扩散 :star:010-3. 正则表达式匹配 动态规划 019-2. 删除链表的倒数第N个节点 链表+快慢指针 022-2. 括号生成 回溯法 :star:031-2. 下一个排列 数组+思维 034-2. ...
leetcode刷题笔记之JavaScript
11-08
在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 二叉树 二叉树是一种树状数据结构，其中每个节点最多有两个孩子节点（左...
Leetcode刷题笔记-大厂面试突破集
08-15
首先，从题目类型上看，涵盖了哈希表、动态规划、前缀和、二分查找、双指针、贪心策略、回溯算法、模拟题、树的遍历、分治策略等多种算法。例如，1001题《网格照明》利用哈希表和线性映射来解决；1004题《最大连续1...
与谷歌高材生一起轻松刷LeetCode探索C++编程技巧分享刷题笔记
05-23
按照题目类型的数量分类，其中最常见的几个题型包括数组、动态规划、数学、字符串、树、哈希表、深度优先搜索、二分查找、贪心算法、广度优先搜索、双指针等。这些题型以及其他流行的题型按照难易程度和类型进行了...
类中vector的初始化问题
qq_42247231的博客
07-10 5533
微信公众号：编程笔记本 微信公众号：编程笔记本 微信公众号：编程笔记本 点击上方蓝字关注我，我们一起学编程 欢迎小伙伴们分享、转载、私信、赞赏 今天分享一个在类中使用 vector 并初始化的小 trick 。 事情的起因是这样的： 在做牛客网的在线编程题时，一个小伙伴问我：“为什么我这里会报错啊？” 题目： 请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g" 。当从该字符流中读出前六个字符 "google" 时，第一
567. Permutation in String
wilzxu的博客
05-06 89
567. Permutation in String方法1: sliding window易错点Complexity Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words, one of the first string’s ...
leetcode200题之哈希表（二）
ttdss12345678的博客
08-29 295
1. 有效的字母异位词 法一：排序 通过将 s的字母重新排列成 t来生成变位词。因此，如果 t 是 s 的变位词，对两个字符串进行排序将产生两个相同的字符串。此外，如果 s 和 t的长度不同，t不能是 s的变位词，我们可以提前返回。 法二：哈希表 为了检查 t是否是 s 的重新排列，我们可以计算两个字符串中每个字母的出现次数并进行比较。因为 s和 t 都只包含 a-z 的字母，所以一个简单的 26 位计数器表就足够了。 我们需要两个计数器数表进行比较吗？实际上不是，因为我们可以用一个...
力扣分类刷题（哈希表第一次）
j15941558855的博客
05-30 119
力扣分类刷题（哈希表第一次）
1002. 查找常用字符
qq_41078889的博客
10-14 171
我们可以定义两个哈希数组，因为全是小写字母，所以将哈希数组的大小定为26，将第一个存储字符串第一个数组的值，第二个存放第二个数组，并和第一个数组进行比较，值较小的放在第一个数组，将数组二置为0，并且去遍历第三个数组，以此类推，最后第一个数组中的元素就是要求的公共子字符。 代码如下： class Solution { public: vector<string> commonChars(vector<string>& A) { v..
Leetcode 哈希表（一）
Ivvvyy的博客
02-24 300
242. 有效的字母异位词 力扣题目链接 class Solution { public: bool isAnagram(string s, string t) { int record[26] = {0}; for(int i = 0; i < s.size(); i++){ record[s[i] - 'a']++; } for(int i = 0; i < t.size(); i++){
no matching function for call to 'ListNode::ListNode()'
CLZHIT的博客
12-16 2562
刷leedcode时编译报错 error: no matching function for call to 'ListNode:ListNode()' 错误原因为结构体ListNode的变量在使用前没有进行初始化操作 另外，结构体变量的指针在使用之前也需要初始化或赋值操作，将原来代码中的ListNode A，改为ListNode A(0),编译成功 ...
leetcode刷题 哈希表 c++
最新发布
01-12
在刷题过程中，我们经常会遇到需要使用哈希表来解决的问题，因此掌握哈希表的相关知识是非常重要的。 C语言是一种非常流行的编程语言，它具有高效的性能和强大的功能，在算法题目的解题过程中也经常会用到。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值