代码随想录DAY6|哈希表|242有效的字母异位词、349两个数组的交集、202快乐数、1 两数之和-CSDN博客

本文链接：https://blog.csdn.net/weixin_43388723/article/details/138136815

前言

详细的包含main函数的代码，小白可直接在vs运行~

一、242.有效的字母异位词

文档&视频讲解：代码随想录

1. 题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母。

2. 思路

用哈希表查找，数值小范围可控用vector
hash[26]统计s中每个字母出现的频率
利用字符串ASCII码的差值对应存储各个字母出现的频率：s++ ->t - -
判定条件是hash[26]==0就是完全相等

3. 代码实现

//Time:2024/4/22
//数组多了，变量多了我就很容易写错变量


#include<iostream>
#include<vector>

using std::cout;
using std::string;


class Solution {
public:
	//bool表示返回值类型是true或false
	bool isAnagram(string s, string t) {

		int hash[26] = { 0 };
		for (int i = 0; i < s.size(); i++) {

			//根据i遍历s,一个个得到字符串的各个字符
			//用s的字符和'a'的差值表示 s的字符 在hash上的索引
			hash[s[i] - 'a']++;
		}

		//遍历完s之后遍历t
		for (int i = 0; i < t.size(); i++) {
			hash[t[i] - 'a']--;
		}

		//如果hash[26]！=0；false
		//先遍历，一个个判断
		for (int i = 0; i < 26; i++) {
			if (hash[i] != 0) {
				return false;
			}
		}
		//是在for之外，所有元素遍历完之后返回true
		return true;
	}
};



int main() {

	Solution solution;
	string s = { "ebbc" };
	string t = { "bbac" };
	bool result = solution.isAnagram(s, t);

	cout << result;


	return 0;
}

4.Debug与收获

2024/4/22一刷

数组多了，变量多了我就很容易写错变量

二、349. 两个数组的交集

文档&视频讲解：代码随想录

1. 题目

题意：给定两个数组，编写一个函数来计算它们的交集。
在这里插入图片描述

说明：输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序

2. 思路

数值很多用set，要去重用unordered_set
将nums1移到unordered_set nums_set
将nums2和其比较
出现过的放到result_set

3. 代码实现

//Time：2024/4/23训练营跟练
#include<iostream>
#include<vector>
#include<unordered_set>

using std::vector;
using std::unordered_set;
using std::cout;
using std::endl;

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        
        //创建函数最终的返回值result_set
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重

        ///复制 nums1 到 nums_set
        unordered_set<int> nums_set(nums1.begin(), nums1.end());

        //用变量 num 来遍历 nums2
        for (int num : nums2) {

            //find在nums_set 找到了 num 就会返回指向该元素的迭代器（指针），然后将该元素insert到result_set
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};


int main() {
    // 测试样例
    vector<int> nums1 = { 1, 2, 2, 1};
    vector<int> nums2 = { 2, 2 };

    Solution solution;
    vector<int> result = solution.intersection(nums1, nums2);

    cout << "Intersection: ";
    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return 0;
}

三、202. 快乐数

文档&视频讲解：代码随想录

1. 题目

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true

解释：

1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

2. 思路

可能会无限循环用：while（1），只有满足条件的跳出循环
先用一个函数getSum计算各位平方和
1. sum==1 true
2. set里有sum（set统计出现过的sum） false
3. set里面有sum sum放入set
4. 改变输入n的值，重新开始循环

3. 代码实现

//Time:2024/4/23
//Debug:
//int sum;初始化sum要初始化他的数据类型和值

#include<iostream>
#include<vector>
#include<set>
#include<unordered_set>

using std::cout;
using std::endl;
using std::unordered_set;
using std::vector;

class Solution {
public:
	//求n每个位上数各自平方之和
	int getSum(int n) {

		int sum = 0;

		while (n) {
			//求现在的个位
			sum += (n % 10) * (n % 10);
			//去除掉个位
			n /= 10;
		}
		return sum;
	}

	//判断是否为快乐数
	bool isHappy(int n) {
		
		

		//记录sum出现过的值
		unordered_set<int> set;
		
		//一直无限循环，除非true或false
		while (1) {

			//sum的计算要放在while循环里，sum的值在while里不断更新变换
			int sum = getSum(n);

			//1.sum==1,true
			if (sum == 1) {
				return true;
			}

			//2.如果sum出现过，就会无限循环，就是false
			if (set.find(sum) != set.end()) {
				return false;
			}

			//3.sum！=0 || 没出现过
			else {
				set.insert(sum);
				n = sum;
			}
		}
	}
};


int main()
{
	Solution solution;
	int n = 19;
	bool result = solution.isHappy(n);
	cout << result << endl;

	return 0;
}

4.Debug与收获

2024/4/23一刷

注意getSum函数要放在while循环里面

四、202. 快乐数

文档&视频讲解：代码随想录

1. 题目

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

2. 思路

用到数组的元素和索引，哈希表用map，优先用unordered_map
查找条件是元素值–key，返回值是索引—value
在已经遍历过的元素（map）中查找，有无目标值减去正在遍历的元素值有就找到了返回value，没有就继续遍历
只用遍历一次，以为map中存储了遍历过的元素，只用一边遍历一边在map中查找

3. 代码实现

//Time:2024/4/23
//哈希表这种结构是用来寻找的，而输入输出的值还是用vector来装


#include<iostream>
#include<unordered_map>
#include<vector>

using std::unordered_map;
using std::vector;
using std::cout;
using std::endl;
using std::pair;

class Solution {
public:
	vector<int> twoSum(vector<int>& nums, int target) {

		//存放遍历过的元素
		unordered_map <int, int> map;

		for (int i = 0; i < nums.size(); i++) {

			//要查询的，能和当前正在遍历元素配对的元素
			auto s = target - nums[i];

			//查找map中是否存在s
			//iter是一个迭代器，它指向std::unordered_map<int, int>类型的map中的某个元素。
			auto iter = map.find(s);

			if (iter != map.end()) {
				//找到了 返回两个下标
				//iter->second表示迭代器iter所指向的键值对中的 value 的部分---也就是下标
				return { iter->second,i };
			}
			
			//没找到就将遍历过的 元素 和 下标 加入到map
			map.insert(pair<int, int>(nums[i], i));

		}

		return {};
	}
};


int main()
{

	Solution solution;
	vector<int> nums = { 2, 7, 11, 15 };
	int target = 9;

	vector<int> result = solution.twoSum(nums, target);

	for (int i = 0; i < result.size(); i++) {
		cout << result[i] << " ";
	}
	cout << endl;

	return 0;
}