《面试算法 LeetCode 刷题班》——7. 哈希表与字符串

最新推荐文章于 2021-07-17 23:06:24 发布
原创 最新推荐文章于 2021-07-17 23:06:24 发布 · 819 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析LeetCode经典算法题目，涵盖哈希表、字符串处理、动态规划等核心概念，通过实例讲解算法设计思路与优化技巧，适合算法初学者及面试备考者。

本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！

7. 哈希表与字符串

文章目录


哈希表： 也叫散列表，根据key直接进行访问得数据结构，比较快速。

问题1：当遇上 负数或非常大的整数，字符串，及浮点数，数组，对象等，如何进行哈希映射？

需要利用哈希函数，将关键字值转换为整数再对表长取余，从而关键字值被转换成哈希表的表长范围内的整数。

问题2: 采用上述方法，但不排除地址冲突（不同元素对应同一个地址）的问题，如何解决？

这就采用拉链法，构造哈希表来解决冲突,可以将哈希表设置为单个的指针数组,每一个指针指向的是哈希函数的结果相同的单链表. 插入时采用头插法,搜索时依次遍历.

实现:

struct  ListNode
{
	int val;
	ListNode *next;
	ListNode (int x) : val(x),next(nullptr) {}
};


int hash_func(int key, int table_len) {
	return key % table_len;
}

void insert(ListNode *hash_table[], ListNode *node, int table_len) { // 头插法
	int hash_key = hash_func(node->val, table_len);
	node->next = hash_table[hash_key];
	hash_table[hash_key] = node;
}

bool search(ListNode *hash_table[], int value, int table_len) {
	int hash_key = hash_func(value, table_len);
	ListNode *head = hash_table[hash_key];
	while (head)
	{
		if (head->val == value) {
			return true;
		}
		head = head->next;
	}
	return false;
}

还可以同 STL 中的 map 包含在 中

LeetCode 409 最长回文串（E）

给定一个字符串,求该字符串可以生成的最长回文字符串长度.

观察回文字符串的特点,字符串长度为奇数时有中心字符,除了中心字符外,或者字符串长度为偶数长度时,其他字符只要头部出现尾部就要对应出现.

本题思路:

  1. 利用字符哈希方法,统计字符串中所有字符的数量
  2. 设置最长回文串偶数字符长度为 max_length = 0
  3. 设置是否有 中心点 标记 flag = 0
  4. 遍历每一个字符,字符数为 count ,若 count 为偶数,则 max_length += count; 若 count 为奇数, max_length + = count - 1, flag = 1;
  5. 最终最长回文字符串长度为 max_length + flag;

解决方法:

class Solution {
public:
int longestPalindrome(string s) {
int char_map[128] = { 0 };
		int max_length = 0;
		int flag = 0;
		for (int i = 0; i < s.length(); i++)
		{
			char_map[s[i]] += 1;
		}

		for (int i = 0; i < 128; i++)
		{
			if (char_map[i] % 2 == 0) {
				max_length += char_map[i];
			}
			else
			{
				max_length += char_map[i] - 1;
				flag = 1;
			}
		}
		return max_length + flag;
	}
};
LeetCode 290 词语模式（E）

已知字符串pattern 与 字符串str, 确认str是否与 pattern匹配,两者均只包含小写字母,以空格间隔. pattern = “abba”, str = “dog cat cat dog” 则为 true ,反之则为 false.

本题思路:

  1. 设置单个 单词 到 字符 的映射（哈希）， 使用数组used[128]记录 pattern 字符是否使用
  2. 遍历所有单词，同时对应的向前移动指向 pattern 字符的指针，每拆分一个单词，做逻辑判断 。
  3. 若单词个数与 pattern 字符个数不匹配，返回 false 。

解决方法:

class Solution {
public:
	bool wordPattern(string pattern, string str) {
		map<string, char> word_map;
		char used[128] = { 0 };
		string word;
		int pos = 0;
		str.push_back(' ');

		for (int i = 0; i < str.length(); i++)
		{
			if (str[i] == ' ')
			{
				if (pos == pattern.length())
				{
					return false;
				}

				if (word_map.find(word) == word_map.end())
				{
					if (used[pattern[pos]]) {  // 单词未出现，字符出现
						return false;
					}
					word_map[word] = pattern[pos];
					used[pattern[pos]] = 1;
				}
				else
				{
					if (word_map[word] != pattern[pos])
					{
						return false; // 单词出现，字符未出现
					}
				}
				word = "";  // 完成一个单词的插入和查询后，清空word
				pos++; // 指向pattern字符的pos 指针前移
			}
			else {
				word += str[i]; // 读取字符
			}
		}
		if (pos != pattern.length())
		{
			return false; // 有多余的pattern字符
		}
		return true;
	}
};
LeetCode 49 同字符词语分组（M）

已知一组字符串，将所有由颠倒字母顺序构成的字放到一起输出。

Example:

Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
Output:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

本题思路1:

设置字符串到字符串向量的哈希表。遍历字符串向量strs中的单词strs[i]：

  1. 设置临时变量 str=strs[i]，对str进行排序
  2. 若str未出现在anagram中，设置str到一个空字符串向量的映射
  3. 将strs[i]添加到字符串向量 anagram[str]中

遍历哈希表 anagram，将全部key对应的value push至最终结果中

解决方法:

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {

		map<string, vector<string>> anagram;
		vector<vector<string>> result;
		for (int i = 0; i < strs.size(); i++)
		{
			string str = strs[i];
			sort(str.begin(), str.end());
			if (anagram.find(str) == anagram.end())
			{
				vector<string> item;
				anagram[str] = item;
			}
			anagram[str].push_back(strs[i]);
		}

		map<string, vector<string>>::iterator it;
		for  (it = anagram.begin();it != anagram.end() ; it++)
		{
			result.push_back((*it).second);
		}
		return result;
	}
};

本题思路2:

将字符串映射到26个字母的字符数量为 key ， 以字符串向量为 value ，剩余过程同上。

解决方法:

void change_to_vector(string &str, vector<int> &vec) {
	for (int i = 0; i < 26; i++)
	{
		vec.push_back(0);
	}

	for (int i = 0; i < str.length(); i++)
	{
		vec[str[i] - 'a']++;
	}
}

class Solution {
public:
	vector<vector<string>> groupAnagrams(vector<string>& strs) {

		map<vector<int>, vector<string>> anagram;
		vector<vector<string>> result;
		for (int i = 0; i < strs.size(); i++)
		{
			vector<int> vec;
			change_to_vector(strs[i], vec);
			if (anagram.find(vec) == anagram.end())
			{
				vector<string> item;
				anagram[vec] = item;
			}
			anagram[vec].push_back(strs[i]);
		}

		map<vector<int>, vector<string>>::iterator it;
		for  (it = anagram.begin();it != anagram.end() ; it++)
		{
			result.push_back((*it).second);
		}
		return result;
	}
};
LeetCode 3 无重复字符的最长字串（M）

本题思路:

  1. 设置一个记录字符数量的字符哈希， char_map
  2. 设置一个记录当前满足条件的最长子串变量 word；
  3. 设置两个指针( i 和 j )指向字符串的第一个字符
  4. 设置最长满足条件的字串的长度 result
  5. i 指针向后逐个扫描字符串的字符，使用 char_map 记录字符数量，如果word中没有出现该字符，对word尾部添加字符并检查result是否需要更新；否则 j 向前移动，更新 char_map 的字符数量，直到字符s[i]的数量为1；更新 word ，将 word 赋值为 j 和 i 之间的字串。

解决方法:

class Solution {
public:
	int lengthOfLongestSubstring(string s) {
		int j = 0;
		int result = 0;
		string word = "";
		int char_map[128] = { 0 };
		for (int i = 0; i < s.length(); i++)
		{
			char_map[s[i]]++;
			if (char_map[s[i]] == 1)
			{
				word.push_back(s[i]);
				if (result < word.length())
				{
					result = word.length();
				}
			}
			else
			{
				while (j<i && char_map[s[i]] >1)
				{
					char_map[s[j]]--;
					j++;
				}
			}
			word = "";
			for (int k = j; k <= i; k++)
			{
				word += s[k];
			}
		}
		return result;
	}
};
LeetCode 187 重复的 DNA 序列（M）

将 DNA 序列看作只包含[‘A’,‘C’,‘G’,‘T’] 4个字符的字符串，给一个DNA字符串，找到所有长度为10的，且超过1次的子串。

本题思路1:

依次取出给定的字符串中所有长度为 10 的字符串，然后使用 map 来统计字串出现个数，然后输出，复杂度为 O（n）

解决方法:

class Solution {
public:
	vector<string> findRepeatedDnaSequences(string s) {
		vector<string> result;
		map<string, int> word_map;

		for (int i = 0; i < s.length(); i++)
		{
			string word = s.substr(i, 10);
			if (word_map.find(word) != word_map.end())
			{
				word_map[word]++;
			}
			else
			{
				word_map[word] = 1;
			}
		}
		map<string, int>::iterator it;
		for (it = word_map.begin();  it !=word_map.end(); it++)
		{
			if ( (*it).second > 1 ) {
				result.push_back(it->first);
			}
		}
		return result;
	}
};

本题思路2:

？？？？

LeetCode 76 最小窗口子串（H）

已知字符串S与字符串T，求S在的最小窗口（区间），使得这个区间中包含了字符串T中的所有字符。

Example:

Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"

本题思路1:

1.设置两个 字符哈希 数组， map_s 和 map_t代表当前处理的窗口区间中的字符变量，map_t 代表子串 T 的字符数量。

2.设置两个指针（ i 和 begin）指向字符第一个字符

3.i 指针向后逐个扫描字符串中的字符，在这个过程中，循环检查 begin 指针是否可以向前移动：

如果当前 begin 指向的字符T中没出现，直接前移 begin；

如果 begin 指向的字符T中出现了，但是当前区间窗口中的该字符数量足够，向前移动 begin， 并更新 map_s

否则不能移动 begin， 跳出检查

4.指针i 每向前扫描一个字符，即检查一下是否可以更新最终结果

在整个过程中，使用 begin 和 i 维护一个窗口， 该窗口中的子串满足题目条件，窗口线性向前滑动，整体复杂度为 O（n）。

解决方法:

class Solution {
public:

	bool is_window_ok(int map_s[], int map_t[] , vector<int> &vec_t) {
		for (int i = 0; i < vec_t.size(); i++) {
			if (map_s[vec_t[i]] < map_t[vec_t[i]]) // 遍历 t 中字符
			{
				return false; // 若s出现该字符的数量小于 t 中出现的数量
			}
		} 
		return true;
	}

	string minWindow(string s, string t) {
		const int MAX_ARRAY_LEN = 128;
		int map_s[MAX_ARRAY_LEN] = { 0 }; //记录 s 字符串各字符个数
		int map_t[MAX_ARRAY_LEN] = { 0 }; //记录 t 字符串各字符个数

		vector<int> vec_t;
		for (int i = 0; i < t.length(); i++)
		{
			map_t[t[i]]++;
		}

		for (int i = 0; i < MAX_ARRAY_LEN; i++)
		{
			if (map_t[i] > 0) {
				vec_t.push_back(i);  // 遍历，将字符串t中出现的字符存储到 vec_t中
			}
		}

		int window_begin = 0;
		string result;

		for (int i = 0; i < s.length(); i++)
		{
			map_s[s[i]]++;
			while (window_begin < i)
			{
				char begin_ch = s[window_begin];
				if (map_t[begin_ch] == 0)
				{
					window_begin++;
				}
				else if (map_s[begin_ch] > map_t[begin_ch]) {
					map_s[begin_ch]--;
					window_begin++;
				}
				else
				{
					break;
				}
			}
			if (is_window_ok(map_s,map_t,vec_t))
			{
				int new_window_len = i - window_begin + 1;
				if (result =="" || result.length() > new_window_len)
				{
					result = s.substr(window_begin, new_window_len);
				}
			}
		}
		return result;
	}
};
面试算法LeetCode刷题班
04-26
课程将程序员面试中常遇的算法与数据结构知识进行精简与归纳，细致入微地讲解笔试面试中的编程真题和相关知识点; 以leetcode.com、codeforces.com中的题目为例题，利用OJ刷题的方式提升学员的编码能力与解决算法面试题的能力
LeetCode刷题笔记——#3. 无重复字符的最长子串
12-22
LeetCode中的第3题是一个经典的字符串处理问题，名为“无重复字符的最长子串”。问题要求找到给定字符串中最长的一个子串，这个子串中不包含任何重复的字符。例如，对于字符串 "pwwkew"，最长的无重复字符子串是 ...
《面试算法 LeetCode 刷题班》—— 1. 链表
qq_44744450的博客
07-17 465
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 1.链表 文章目录 1.链表LeetCode 206 链表逆序 a （E）LeetCode 92 链表逆序 b（M）LeetCode 160 求两个链表的交点（E）LeetCode 141 & 142 链表求环（M） （快慢指针问题）LeetCode 86 链表划分（M）LeetCode 21 排序链表合并（2个）（E）LeetCode 23 排序链表合并（多个）（H）Le..
《面试算法 LeetCode 刷题班》——4. 递归，回溯，分治
Chris_zhangrx的博客
11-28 2368
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 4. 递归，回溯，分治 文章目录4. 递归，回溯，分治LeetCode 78 求子级（M）LeetCode 90 求子集2（M）LeetCode 40 组合数之和2（M）LeetCode 22 生成括号（M）LeetCode 51 N 皇后（H）LeetCode 315 逆序数（H） Lee...
面试算法LeetCode代码与讲解视频之哈希表与字符串
最新发布
09-06
哈希表与字符串是面试算法中的重要部分，尤其在LeetCode这样的在线编程平台上，这两种数据结构的运用非常广泛。哈希表是一种通过哈希函数组织数据，以支持快速插入和搜索操作的散列表数据结构，它在处理大量数据时...
精选资源
LeetCode 刷题笔记 with Java.zip
11-23
第一部分的笔记《LeetCode 刷题笔记 with Java 1-50》主要包含了LeetCode前50题的解法，包括基础的数组操作、字符串处理、链表操作等。例如，"Two Sum"（两数之和）题目中，开发者会学习到如何高效地查找两个数字的...
精选资源
1_leetcode刷题指南.pdf
05-08
上述各个类别的问题类型和相关知识点是leetcode平台上常见的题型，涵盖了编程中最基本和最重要的概念与技巧，对于准备面试、提升算法能力或解决实际编程问题都有极大的帮助。通过刷题，可以有效提高逻辑思维能力和...
LeetCode刷题笔记：数组与哈希表高频考点解析
该笔记涵盖了多个数据结构与算法模块，包括链表、栈、堆与队列、二叉树、哈希表、数学、数组、字符串、位运算等，并按照简单、中等、困难三个难度等级进行了分类标记，说明这是一个系统性整理的LeetCode刷题记录。...
算法刷题LeetCode
01-08
算法刷题LeetCode 算法刷题LeetCode 算法刷题LeetCode
面试算法LeetCode刷题班—BAT面试官带你刷真题、过笔试
qq_44744450的博客
07-16 500
课程名称: 《面试算法LeetCode刷题班》 ——BAT面试官带你刷真题、过笔试 主讲老师: 林老师 BAT资深研发工程师(T7/P8级)，致力于搜索引擎及其子系统的研发、迭代与优化，数据分析与挖掘领域专家，多年担任校园招聘、社会招聘面试官，丰富的面试候选人经验。 课程简介: 掌握算法与数据结构是成为优秀程序员的必经之路，众多国内外知名互联网企业都将算法面试作为程序员招聘的重要和必需途径，只有高效应对各类题目，将知识储备转化为面试中的优秀表现，才能获得大公司的青睐。 本门课程将程序员面试中常遇的算法与数据
《面试算法 LeetCode 刷题班》——10.复杂数据结构
qq_44744450的博客
07-17 500
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 9. 动态规划 文章目录 9. 动态规划LeetCode 70 爬楼梯 (E)LeetCode 198 打家劫舍 （E）LeetCode 53 最大子段和（E）LeetCode 322 找零钱（M）LeetCode 120 三角形（M）LeetCode 300 最长上升子序列LeetCode 64 最小路径和（M）LeetCode 174 地牢游戏（H） Leet.
《面试算法 LeetCode 刷题班》——5.二叉树与图
Chris_zhangrx的博客
11-28 1296
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 5. 二叉树与图 文章目录5. 二叉树与图leetCode 113 路径之和2LeetCode 236 最近的公共祖先LeetCode 114 二叉树转链表LeetCode 199 侧面观察二叉树LeetCode 207 课程安排 leetCode 113 路径之和2 这里题目已经事先定义了...
《面试算法 LeetCode 刷题班》——6.二分查找与二叉查找树
Chris_zhangrx的博客
11-28 719
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 6.二叉查找与二叉查找树 文章目录6.二叉查找与二叉查找树LeetCode 35 插入位置LeetCode 34 查找区间LeetCode 33 旋转数组查找LeetCode 449LeetCode 315 逆序数 （解法2） 二分查找的递归实现 bool binary_search(v...
leetcode 刷题为面试准备
liwei的专栏
03-31 1435
1.Two Sum 这题刚开始想用O(N)的方法，但是发现如果用数组标记 [ target-numbers[i] ] 的话，可能会有负数的情况，所以就两个for循环想暴力看看能不能过的，一交发现T了。然后想了下，数组其实可以用map解决，把map当成数组用得了，可以标记负数的情况。java中也有，phthon还没用过。 2.
leetcode面试算法题
那时候的坚持不懈的我的博客
08-20 1604
数组 旋转数组(向右移k位, 头条) 思路: 1 2 3 4 5 6 7　　如果k = 3 的话， 会变成 5 6 7 1 2 3 4 　　1 2 3 4 5 6 7　　middle = 7 - 3 = 4，分为左边 4个数字，右边 3个数字 　　4 3 2 1 7 6 5　　分别把左右reverse 一下 　　5 6 7 1 2 3 4　　把总数组reverse 一下就会得到答案...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值