哈希表与字符串

最新推荐文章于 2025-10-19 22:51:20 发布
原创 最新推荐文章于 2025-10-19 22:51:20 发布 · 2.9k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了使用哈希表解决最长回文串、单词模式匹配、字母异位词分组、无重复字符子串、重复DNA序列和最小覆盖子串等LeetCode题目，通过哈希表的高效特性来优化算法解决方案。
部署运行你感兴趣的模型镜像

预备知识：
在这里插入图片描述
1、最简单的哈希-----字符哈希

#include<stdio.h>
#include<string>
#include<stdlib.h>
using namespace std;

int main(){
	int char_map[128] = {0};//ASCⅡ码从0-127，故用数组下标做映射，最大范围至128
	string str="snaxjnjsxngdpq";
	for(int i=0;i<str.length();i++){
		char_map[str[i]]++;//统计字符串中各个字符的数量
	}
	for(int i=0;i<128;i++){
		if(char_map[i]>0)
			printf("[%c][%d]: %d\n",i,i,char_map[i]);//将字符对应的ASCⅡ码及其个数打印出来
	}
	system("pause");
	return 0;
}

在这里插入图片描述
2、哈希表排序整数

#include<stdio.h>
#include<stdlib.h>
using namespace std;

int main(){
	int random[10] = {3,456,78,43,124,789,908,78,3,124};
	int hash_map[1000] = {0};//哈希表长度需要超过最大排序数
	for(int i=0;i<10;i++){
		hash_map[random[i]]++;//统计字符串中各个字符的数量
	}
	for(int i=0;i<1000;i++){
		//从小到大查询hash表中是否出现该数字，若出现则全部打出，打印结果就为排序后de
		for(int j = 0;j < hash_map[i];j++){
			printf("%d\n",i);
		}	
	}
	system("pause");
	return 0;
}

在这里插入图片描述
问题1：如何利用哈希表实现对任意字符的映射？
在这里插入图片描述
问题2：利用上述方式映射发生冲突怎么办？
用拉链法解决
在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<vector>
using namespace std;
struct ListNode{
	int val;
	ListNode *next;
	ListNode(int x):val(x),next(NULL){}
};

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);//将插入节点的值转换为hash关键值
	node->next = hash_table[hash_key];//利用头插法将新的节点插入对应哈希值位置
	hash_table[hash_key] = node;
}

bool search(ListNode *hash_table[],int value,int table_len){//查找value值
	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;
}
int main(){
	const int TABLE_LEN = 11;//！！！去质数冲突会比较小
	ListNode *hash_table[TABLE_LEN]={0};
	vector<ListNode*> hash_node_vec;
	int test[8] = {14,17,404,109,9,6,7,81};//测试数组
	for(int i=0;i<8;i++) //以此生成相应节点并将测试数组的值存进数组中
		hash_node_vec.push_back(new ListNode(test[i]));
	for(int i=0;i<hash_node_vec.size();i++)
		insert(hash_table,hash_node_vec[i],TABLE_LEN);//将节点插入哈希表
	printf("Hash table:\n");
	for(int i=0;i<TABLE_LEN;i++){//打印哈希表
		printf("[%d]",i);
		ListNode* head=hash_table[i];
		while(head){
			printf("->%d",head->val);
			head=head->next;
		}
		printf("\n");
	}
	printf("\n");
	printf("Test search:\n");
	for(int i=0;i<10;i++){//查找相应的值在不在表中
		if(search(hash_table,i,TABLE_LEN))
			printf("%d is in the hash table.\n",i);
		else
			printf("%d is not in the hash table.\n",i);
	}
	system("pause");
	return 0;
}

在这里插入图片描述

一、最长回文串 LeetCode409

题目：
给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。
在构造过程中，请注意区分大小写。比如 “Aa” 不能当做一个回文字符串。
注意:
假设字符串的长度不会超过 1010。
示例 1:
输入:
“abccccdd”
输出:
7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
思路：
在这里插入图片描述

class Solution {
public:
    int longestPalindrome(string s) {
        int char_map[128]={0};//哈希表
        int char_length = 0;//回文串长度
        int flag = 0;//有无中心字符
        for(int i=0;i<s.length();i++){
            char_map[s[i]]++;//统计每个字符出现的次数
        }
        for(int i=0;i<128;i++){
            if(char_map[i]%2==0)
                char_length +=char_map[i];
            else{
                char_length +=char_map[i]-1;
                flag = 1;//有中心字符
            }
        }
        return char_length+flag;
    }
};

**二、单词模式 LeetCode290 **

题目：
给定一种 pattern(模式) 和一个字符串 str ，判断 str 是否遵循相同的模式。
这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应模式。
示例1:
输入: pattern = “abba”, str = “dog cat cat dog”
输出: true
示例 2:
输入:pattern = “abba”, str = “dog cat cat fish”
输出: false
在这里插入图片描述

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        map<string, char> word_map;//单词到pattern的映射
        char used[128] = {0};//已经被映射的pattern字符
        string word;//被拆分出来的单词
        int pos = 0;//当前指向的pattern字符
        str.push_back(' ');//尾部输入一个空格，最后一个单词就不用特殊处理了
        for(int i=0;i<str.length();i++){
            if(str[i]==' '){//遇到空格则拆分出新单词了
                if(pos==pattern.length()){//如果pattern已经没有字符与之对应了，返回false
                    return false;
                }
            if(word_map.find(word) == word_map.end()){
                //如果该单词从未出现,但是对应字符已经被用返回false
                if(used[pattern[pos]])
                    return false;
                else{//如果对应字符没出现，则将其余相应单词对应，并且在used数组中记录
                    word_map[word] = pattern[pos];  
                    used[pattern[pos]] = 1;
                }
            }
            else{//之前已经出现了,但是字符串对应不上
                    if(word_map[word]!=pattern[pos])
                         return false;            
                }
            word="";//处理完一个单词word置为空
            pos++;//字符移向下一个位置
            }
           else //没有拆分出新单词
              word += str[i];
        }
        if(pos!=pattern.length())//如果字符串已经遍历完了，pos还没到结尾就说明字符比单词多
            return false;
		return true;
    }
	
};

三、字母异位词分组 LeetCode 49

题目：
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例:
输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]
思路：
方法I，设计一个哈希表以内部进行排序后的各个单词为key，以字符串向量为value，存储各个字符数量相同的字符串
在这里插入图片描述
方法1思路
在这里插入图片描述

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> result;//用来存储结果
        map<string,vector<string>> anagram;//排序后的各个单词为key，字符串向量为value，对应存储在anagram中
        for(int i= 0;i< strs.size();i++){//遍历各个单词
            string str = strs[i];//遍历各个单词
            sort(str.begin(),str.end());//将str中的字符排序
            if(anagram.find(str) == anagram.end()){//如果anagram中没有找到的话
                vector<string> item;//设置一个空的字符向量，来存储这类字符
                anagram[str] = item;//将key值与存储空间对应起来
            }
            anagram[str].push_back(strs[i]);//将字符串的值push进来
        }
        //建立一个与anagram同类型的迭代器，遍历输出结果
        map<string,vector<string>>::iterator it;
        for(it = anagram.begin();it!=anagram.end();it++){
            result.push_back((*it).second);
        }
        return result;
    }
};

方法2：
在这里插入图片描述
思路：
在这里插入图片描述

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++){//将str中字母个数进行统计
        vec[str[i]-'a']++;
    }
}
class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> result;//用来存储结果
        map<vector<int>,vector<string>> anagram;//排序后的各个单词为key，字符串向量为value，对应存储在anagram中
        for(int i= 0;i< strs.size();i++){//遍历各个单词
            vector<int> vec;//用来存储单词中字母出现的数量
            change_to_vector(strs[i],vec);
            if(anagram.find(vec) == anagram.end()){//如果anagram中没有找同样数量的词
                vector<string> item;//设置一个空的字符向量，来存储这类字符
                anagram[vec] = item;//将key值与存储空间对应起来
            }
            anagram[vec].push_back(strs[i]);//将字符串的值push进来
        }
        //建立一个与anagram同类型的迭代器，遍历输出结果
        map<vector<int>,vector<string>>::iterator it;
        for(it = anagram.begin();it!=anagram.end();it++){
            result.push_back((*it).second);
        }
        return result;
    }
};

四、无重复字符的最长子串 LeetCode 3

题目：
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
思路：
在这里插入图片描述

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int begin=0;//单词开始的字符
        int i=0;//扫描字符串
        int result =0;//不含重复字符的最长子串
        int char_map[128]={0};//哈希表
        string word ="";//用来存子串
        for(;i<s.length();i++){
            char_map[s[i]]++;//在表中记录相应字符出现的次数
            if(char_map[s[i]]==1){
                //无重复字符
                word+=s[i];//更新子串长度
                if(result<word.length())
                    //如果结果小于word长度更新result
                    result = word.length();
            }
            else{
                //有重复字符就从begin开始删字符，直到没有重复字符，并且begin不能超过i
                while(char_map[s[i]]>1 && begin<i){
                    char_map[s[begin]]--;
                    begin++;
                }
                //再重新更新word
                word="";
                for(int j=begin;j<=i;j++)//!!!不能忘了等号否则最后一个字母会记录不到
                    word+=s[j];
            }
        }
        return result;
    }
};

五、重复的DNA序列 LeetCode187

题目：
所有 DNA 由一系列缩写为 A，C，G 和 T 的核苷酸组成，例如：“ACGAATTCCG”。在研究 DNA 时，识别 DNA 中的重复序列有时会对研究非常有帮助。
编写一个函数来查找 DNA 分子中所有出现超过一次的10个字母长的序列（子串）。
示例:
输入: s = “AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT”
输出: [“AAAAACCCCC”, “CCCCCAAAAA”]
思路1：
因为子串的数量并不大，只有10，可以直接利用枚举的方式。
枚举DNA字符串中所有长度为10的子串，将其插入到哈希map中，记录子串数量；遍历哈希map，将所有子串存储到结果中。算法复杂度O(n).

class Solution {
public:
    vector<string> findRepeatedDnaSequences(string s) {
        map<string,int> word_map;//<子串，子串数量>的映射
        vector<string> result;//满足条件的子串
        for(int i=0;i<s.length();i++){
            string word=s.substr(i,10);//让子串等于s的第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++){//遍历哈希map
            if(it->second>1)//如果子串出现超过1
                result.push_back(it->first);
        }
        return result;
    }
};

思路2：
计算机为大端存储
检测计算机为大端存储还是小端存储的方法：

short x;
    char x0;
    x=0x1122;
	x0=((char*)&x)[0];
    if(x0==0x11)
		printf("da\n");
	else
		printf("xiao\n");

将长度为10的DNA序列进行整数编码：ACGT,分别用0123的二进制表示，故长度为10的DNA序列可以用20个比特位的整数所表示。
在这里插入图片描述

大端存储
using namespace std;

int g_hash_map[1048576] = {0};
 
string change_int_to_DNA(int DNA){
	static const char DNA_CHAR[]={'A','C','G','T'};
	string str;
	for(int i = 0; i < 10;i++){
		str += DNA_CHAR[DNA&3];//长度为10的片段，冲整型转换成字符
		DNA = DNA>>2;
	}
	return str;
}
class Solution {
public:
	vector<string> findRepeatedDnaSequences(string s){
		vector<string> result;
		if(s.length() < 10){
			return result;
		}
		for(int i=0; i < 1048576;i++){//每次调用时更新全局哈希数组
			g_hash_map[i] = 0;
		}
		int char_map[128]={0};//设置字符到整数的转换数组
		char_map['A']=0;
		char_map['C']=1;
		char_map['G']=2;
		char_map['T']=3;
		int key = 0;
		for(int i = 9;i>=0;i--){//将DNA字符串前十个字符转化成相应的关键字
			key = (key<<2)+char_map[s[i]];
		}
		g_hash_map[key] = 1;//并记录出现的字符
		for(int i=10; i < s.length();i++){//遍历后面的字符，将其放进高位，并在哈希数组中记录
			key = key>>2;
			key = key|(char_map[s[i]]<<18);
			g_hash_map[key]++;
		}
		for(int i=0;i<1048576;i++){//扫描哈希数组，出现次数大于1的放进结果中
			if(g_hash_map[i]>1)
				result.push_back(change_int_to_DNA(i));
		}
		return result;
	}
};

小端存储
#include <stdio.h>
#include <vector>
#include <string>
#include <stdlib.h>
#include <iostream>
using namespace std;

int g_hash_map[1048576] = {0};
 
string change_int_to_DNA(int DNA){
	static const char DNA_CHAR[]={'A','C','G','T'};
	string str;
	for(int i = 9; i >= 0;i--){
		str += DNA_CHAR[(DNA&(3<<(2*i)))>>(2*i)];//长度为10的片段，冲整型转换成字符
		//DNA = DNA>>2;
	}
	return str;
}
class Solution {
public:
	vector<string> findRepeatedDnaSequences(string s){
		vector<string> result;
		if(s.length() < 10){
			return result;
		}
		for(int i=0; i < 1048576;i++){//每次调用时更新全局哈希数组
			g_hash_map[i] = 0;
		}
		int char_map[128]={0};//设置字符到整数的转换数组
		char_map['A']=0;
		char_map['C']=1;
		char_map['G']=2;
		char_map['T']=3;
		int key = 0;
		for(int i = 0;i<=9;i++){//将DNA字符串前十个字符转化成相应的关键字
			key = (key<<2)+char_map[s[i]];
		}
		g_hash_map[key] = 1;//并记录出现的字符
		for(int i=10; i < s.length();i++){//遍历后面的字符，将其放进高位，并在哈希数组中记录
			key = (key<<2)&(~(3<<20));
			key = key + char_map[s[i]];
			//key = key|char_map[s[i]];
			g_hash_map[key]++;
		}
		for(int i=0;i<1048576;i++){//扫描哈希数组，出现次数大于1的放进结果中
			if(g_hash_map[i] > 1)
				result.push_back(change_int_to_DNA(i));
		}
		return result;
	}
};

void main()
{
	
	string s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT";
	Solution solve;
	vector<string> res=solve.findRepeatedDnaSequences(s);
	for(int i=0;i < res.size();i++)
		cout<<res[i]<<'\n';//printf("%s\n",result[i].c_str());
	cout<<endl;
	system("pause");
}

！！！只要知道字符存储的方式是大端就行了，计算机的大小端只会影响最后的输出顺序

六、最小覆盖子串 LeetCode76

题目：
给定一个字符串 S 和一个字符串 T，请在 S 中找出包含 T 所有字母的最小子串。
示例：
输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”
思路：
在这里插入图片描述

class Solution {
public:
    string minWindow(string s, string t) {
        const int MAX_ARRAY_LEN = 128;// 数组下标
        int map_t[MAX_ARRAY_LEN] = {0};//存储t中各字符出现次数
        int map_s[MAX_ARRAY_LEN] = {0};//存储当前窗口各字符出现次数
        vector<int> vec_t;//记录t中字符
        int window_begin = 0;//最小窗口起始指针
        string result;//最小窗口对应的字符串
        for(int i=0;i < t.length();i++)//记录t中字符出现次数
            map_t[t[i]]++;
        for(int i=0;i < MAX_ARRAY_LEN;i++){//遍历将t中出现字符存入vec_t中
            if(map_t[i])
                vec_t.push_back(i);
        }
        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)//如果该字符在t中没有则窗头指针直接后移
                    window_begin++;
                else if(map_s[begin_ch]>map_t[begin_ch]){//如果当前窗口begin_ch字符比较多 则后移窗头指针
                    map_s[begin_ch]--;
                    window_begin++;
                }
                else
                    break;//如果不是以上两种情况则跳出循环
            }
            if(is_window_ok(map_s,map_t,vec_t)){//检查当前的窗口是否包含字符串t
                int new_window_len = i- window_begin+1;//计算当前字符串长度
                if(result==""||result.length()>new_window_len)//如果result为空或者长度大于新窗口的长度则更新
                    result = s.substr(window_begin,new_window_len);
            }
        }
        return result;
    }
private:
    bool is_window_ok(int map_s[],int map_t[],vector<int> &vec_t){
        //map_s表示当前窗口字符数量，map_t表示t中字符数量，vec_存储t中所有字符
        for(int i=0;i<vec_t.size();i++){
            if(map_s[vec_t[i]] < map_t[vec_t[i]])//如果s出现该字符数量少于t则返回false
                return false;
        }
        return true;
    }
};

您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

acwing-841.字符串哈希
weixin_43211195的博客
04-19 550
题目描述 给定一个长度为 n 的字符串，再给定 m 个询问，每个询问包含四个整数 l1,r1,l2,r2，请你判断 [l1,r1] 和 [l2,r2] 这两个区间所包含的字符串子串是否完全相同。 字符串中只包含大小写英文字母和数字。 输入格式 第一行包含整数 n 和 m，表示字符串长度和询问次数。 第二行包含一个长度为 n 的字符串，字符串中只包含大小写英文字母和数字。 接下来 m 行，每行包含四个整数 l1,r1,l2,r2，表示一次询问所涉及的两个区间。 注意，字符串的位置从 1 开始编号。 输出格式
【字符串】Hash表
SY奇星的OI博客
04-01 465
指的是当两个或多个不同的数据具有相同的哈希值时发生的现象hash是处理字符串问题中不可缺少的元素，具体应用见下一期：hash表的应用。
字符串哈希：原理、应用及实现要点，你了解多少？
最新发布
2301_79655480的博客
10-19 407
一种把任意长度字符串映射成固定长度数值的技术，是字符串哈希，这种转换能让我们快速比较字符串内容，为字符串匹配这一领域，还有数据校验以及密码学等领域提供了基础支持
用C语言实现常用的字符串哈希函数
01-12
用C语言实现常用的字符串哈希函数，比如RSHash、JSHash、PJWHash、FNVHash等
字符串哈希
weixin_55812984的博客
11-26 1057
给定一个长度为nn的字符串，再给定mm个询问，每个询问包含四个整数l1,r1,l2,r2l1,r1,l2,r2，请你判断[l1,r1][l1,r1]和[l2,r2][l2,r2]这两个区间所包含的字符串子串是否完全相同。 字符串中只包含大小写英文字母和数字。 输入格式 第一行包含整数nn和mm，表示字符串长度和询问次数。 第二行包含一个长度为nn的字符串，字符串中只包含大小写英文字母和数字。 接下来mm行，每行包含四个整数l1,r1,l2,r2l1,r1,l2,r...
字符串哈希 哈希表
weixin_30293079的博客
02-13 298
1.字符串哈希 方法概述： 选取两个合适的互质常数b,h(b<h)，把字符串看成b进制数，算出这个数模h 设H(C,k)为前k个字符构成的字符串的哈希值，则：H(C',k)=H(C,k+n)-H(C,k)*bn ...
面试算法LeetCode代码与讲解视频之哈希表与字符串
09-06
哈希表与字符串是面试算法中的重要部分，尤其在LeetCode这样的在线编程平台上，这两种数据结构的运用非常广泛。哈希表是一种通过哈希函数组织数据，以支持快速插入和搜索操作的散列表数据结构，它在处理大量数据时...
【计算机科学】哈希表与字符串哈希技术详解：数据结构、函数设计及冲突处理方法综述
08-21
内容概要：本文详细介绍了哈希表及其相关概念和技术细节，包括哈希表的引入、哈希函数的设计、冲突处理机制、字符串哈希的基础、哈希错误率分析以及哈希的改进与应用。哈希表作为一种高效的数据结构，通过键值对存储...
【数据结构与算法】哈希表——字符串匹配
qq_74047911的博客
08-13 553
跟原来一样,只不过关键码的类型不在是整型了,c++中的字符串是const char*,所以这里用的const void*.原来我们讲的都是以整数作为关键码,那么我们可不可以用字符串来作为关键码呢?可以将不同的字符串转换成为不同的数字,就方便我们进行取余分组了.这是关键码的类型改变了一下,其他都一样,就不讲了.答案是基本思想还是不变,哈希函数求余来进行分组.那么如果我们也想用哈希表存储,我们该怎么办呢?那么就需要我们进行转换了,就是大名鼎鼎的。有的时候我们希望能够很快的查找字符串.但是字符串怎么可能求取呢?
Java C++ Python 哈希表 栈 字符串等非常实用的操作
01-20
哈希表 创建哈希表： HashMacp map=new HashMap(){{ put(')','('); put(']','('); put('}','{'); }}; 字符串和字符 将字符串转化为字符数组： char chrs[]=s.toCharArray(); 删除字符串的头尾空白符: str=str.trim()...
c语言面试题之哈希表字符串中的第一个唯一字符.zip
03-29
综上所述，解决“C语言面试题之哈希表字符串中的第一个唯一字符”不仅要求掌握C语言的基础语法，还需理解哈希表的原理和应用，以及具备良好的算法设计和分析能力。熟练掌握这些知识点，对于提升C语言编程技能和应对...
哈希表--关键字字符串
09-11
/* *@parameter key is the value it need to convert *@parameter len is the length of key,but not the size of the array *@parameter len_table is the size of table * * */ int replicate(char key[], unsigned int len, unsigned int len_table);
哈希表【字符串哈希】
bettle_king的博客
06-01 276
目录前言两种存储方法字符串哈希 前言 两种存储方法 开放寻址法： 就是找到对应的坑位，如果坑位上有人了就向后找到空的坑位，如果找到了了最后面，就从头接着找。 注意: 数组尽量开大一点，让坑位多一点。 拉链法： 解决冲突时，就在该位置拉一条链。类似于邻接表。 https://www.acwing.com/problem/content/842/ 开放寻址法： 我觉得N开大点有以下几个好处： 1、坑位多了，冲突是更容易找到了 2、如果开的小的话，假如插入的数把坑位都占了，此时下面的语句在一个查找一个不存在
C# 统计文章中字符的种类和个数 哈希表和字典的使用
weixin_34107739的博客
11-01 153
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace Dictionary测试 { class Program { static void...
❤数据结构❤——字符串哈希表
向梦想前进
10-02 709
字符串哈希 简介 字符串哈希表全称前缀哈希表，将字符串通过hash函数变成一个p进制的数，使不同的字符串映射到不同的数字上。例如：ABCD字符串，公式为 注意点 任何字符都不能映射成0，否则会出现不同的字符串都映射到0的情况。例如：“A”,"AA"等。 冲突：关于字符串哈希的方式，前人找到如果将P设为131或者13331，Q取2（64），产生冲突的概率及其小，大概十几亿分之一，这里我们认为我们人品足够好，比赛时不会产生冲突 步骤 用公式存放每一个字符串的hash值
字符串哈希表
dxhi11的博客
05-11 2400
从第一个字符串中删除在第二个字符串中出现的所有字符 “We are students” “aeiou” “W r studnts” 我们可以设置两个指针pfast和pslow，初始化时两个都指向字符串中的第一个字符，pfast碰到一个需要删除的字符直接跳过；pfast如果碰到不需要删除的字符，就把该字符复制给pslow，同时pfast后移（继续需找），pslow（指向下一个位置）。这样整个算
字符串的哈希表
pianoの安心小家
07-27 402
放上代码吧，我也不会解释，可以看看ancestor大佬的解析 以后补上 1 #include 2 #define LL unsigned long long 3 using namespace std; 4 LL h[1000000]; 5 LL seed=163; 6 int ans=0; 7 int n; 8 9 int hash(string s
哈希表（字符串哈希）
m0_62593364的博客
02-11 810
如何求字符串哈希？ 举例子：求字符串"ABCD"的哈希值，"ABCD"字符串看成是P进制的(1234)p,其对应的十进制数就是1*p^3+2*p^2+3*p^1+4*p^0,这样就可以把一个字符串转化为一个数字。但是这个数字可能比较大不好存储，所以要对这个数字模一个比较小的数Q，通过取模就可以把这个数即这个字符串映射到0~Q-1之间的一个数。 注意： 1.不能把字母映射成0。例如：A如果映射成0， A (0)p=0,AA (00)p=0 不对 2.减少哈希冲突：经验值p=131或13331，Q=2^
哈希表、字符串
m0_67794241的博客
11-11 1172
std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希， 使用unordered_set 读写效率是最高的，本题并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值