哈希表+字符串+二叉树

最新推荐文章于 2024-08-13 19:12:02 发布
最新推荐文章于 2024-08-13 19:12:02 发布
阅读量792 收藏 15
点赞数 24
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79917093/article/details/136249063
版权
文章详细介绍了哈希表在解决字符串处理、数组操作、二叉树遍历等问题中的应用，如字母异位词判断、数组交集、快乐数计算、两数之和、赎金信验证以及字符串反转等LeetCode题目。同时讨论了二叉树的前序、中序、后序和层序遍历方法。
摘要由CSDN通过智能技术生成

1.哈希表：

哈希表是根据关键码的值而直接进行访问的数据结构

解决问题：一般哈希表都是用来快速判断一个元素是否出现集合里

常见的三种哈希结构

  • 数组
  • set（集合）
  • map(映射)

力扣 242.有效的字母异位词

定义一个数组a记录字符串s里字符出现的次数。把字符映射到数组，再遍历 字符串s的时候，将 s[i] - ‘a’ 所在的元素做++ 操作,统计字符串s中字符出现的次数。检查字符串t中是否出现了这些字符，遍历字符串t，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

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

力扣 349. 两个数组的交集

这题用到unordered_set，unordered_set输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
	unordered_set<int>result;
	unordered_set<int>set(nums1.begin(),nums1.end());
	for(int i:nums2){
		if(set.find(i)!=set.end())
		result.insert(i);
	}
	return vector<int>(result.begin(),result.end());
    }
};

力扣 第202题. 快乐数

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，所以这道题目使用哈希法，来判断这个sum是否重复出现
class Solution {
public:
	int hh(int n) {
	int sum = 0;
	while (n) {
		sum += (n%10) * (n%10);
		n /= 10;
	}	
	return sum;
	}
    bool isHappy(int n) {set <int> t;
	while(1){
    int a;
	a = hh(n);
	
	if (a == 1) return true;
	if (t.find(a) != t.end()) return false;
	else t.insert(a);
	n = a;
	}
    }
};

力扣 1. 两数之和

本题需要一个map来存放我们遍历过的元素，然后在遍历数组的时候去询问这个map，某元素是否出现在这个集合。数组中的元素作为key，value用来存下标。

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

力扣 383. 赎金信

本题用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

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

2.字符串

力扣 541. 反转字符串II

在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k ，然后判断是否需要有反转的区间。

class Solution {
public:
    string reverseStr(string s, int k) {
	for (int i = 0; i < s.size();i += 2*k) {
		if (i + k <= s.size() ) {
		reverse (s.begin()+i, s.begin()+i+k);
		}
		else {
		reverse (s.begin()+i, s.end());
		}
	}
	return s;
    }
};

替换数字

首先扩充数组到每个数字字符替换成 "number" 之后的大小，然后从后向前替换数字字符

#include <bits/stdc++.h>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int count = 0; 
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        s.resize(s.size() + count * 5);
        int sNewSize = s.size();
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] > '9' || s[j] < '0') {
                s[i] = s[j];
            } else {
                s[i] = 'r';s[i - 1] = 'e';s[i - 2] = 'b';s[i - 3] = 'm'; s[i - 4] = 'u';
                s[i - 5] = 'n';
                i -= 5;
            }
        }
        cout << s << endl;
    }
}

力扣 151.翻转字符串里的单词

先移除多余空格，再将整个字符串反转，最后将每个单词反转

class Solution {
public:
	void sc(string& s){
		int sl=0;
		for(int i=0;i<s.size();i++){
			if(s[i]!=' '){
				if(sl!=0) s[sl++]=' ';
				while(i<s.size()&&s[i]!=' '){
					s[sl++]=s[i++];
				}
			}
			
		}
		s.resize(sl);
	}
    string reverseWords(string s) {
	sc(s);
	reverse(s.begin(),s.end());
	int a=0;
	for(int i=0;i<=s.size();i++){
		if(s[i]==' '|| i==s.size()){
			reverse(s.begin()+a,s.begin()+i);a=i+1;
		}
		
	}
	return s;
    }
};

 右旋字符串

通过整体倒序，把两段子串顺序颠倒，两个段子串里的的字符在倒叙一把，负负得正
#include<bits/stdc++.h>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); 
    reverse(s.begin(), s.end()); 
    reverse(s.begin(), s.begin() + n); 
    reverse(s.begin() + n, s.end()); 

    cout << s << endl;

}

3.二叉树

二叉树是一种基础数据结构，也是众多数据结构的基石。

二叉树的递归遍历

力扣 144 二叉树的前序遍历

二叉树的前序遍历是按照中左右的顺序来处理的

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	void t(TreeNode *cur,vector <int> &vec){
		if(cur == NULL) return;
		vec.push_back(cur->val);
		t(cur->left,vec);
		t(cur->right,vec);
		
	}
    vector<int> preorderTraversal(TreeNode* root) {
	vector<int> result; 
	t(root,result);
	return result;
    }
};

力扣 94 二叉树的中序遍历

二叉树的中序遍历是按照左中右的顺序来处理的

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	void t(TreeNode *cur,vector<int>&vec){
		if(cur==NULL) return;
		t(cur->left,vec);
		vec.push_back(cur->val);
		t(cur->right,vec);
		
	}
    vector<int> inorderTraversal(TreeNode* root) {
	vector<int>result;
	t(root,result);
	return result;
    }
};

力扣 145 二叉树的后序遍历

二叉树的后序遍历是按照左右中的顺序来处理的

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	void t(TreeNode *cur,vector<int>&vec){
		if(cur==NULL) return;
		t(cur->left,vec);
		t(cur->right,vec);
		vec.push_back(cur->val);
	}
    vector<int> postorderTraversal(TreeNode* root) {
	vector<int> res;
	t(root,res);
	return res;
    }
};

力扣 102.二叉树的层序遍历

需要用辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
	vector<vector<int>>result;
	queue<TreeNode *>queue;
	if(root!=NULL)queue.push(root);
	while(!queue.empty()){
		vector<int>vec;
		int size=queue.size();
		while(size--){
			TreeNode *node=queue.front();
			queue.pop();
            vec.push_back(node->val);
			if(node->left!=NULL) queue.push(node->left);
			if(node->right!=NULL) queue.push(node->right);
		}
		result.push_back(vec);
	}
	return result;
    }
};

力扣 429.N叉树的层序遍历

这道题一个节点有多个孩子

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>result;
	queue<Node *>queue;
	if(root!=NULL)queue.push(root);
	while(!queue.empty()){
		vector<int>vec;
		int size=queue.size();
		while(size--){
			Node *node=queue.front();
			queue.pop();
            vec.push_back(node->val);
            for(int i=0;i<node->children.size();i++){
            	if(node->children[i]) queue.push(node->children[i]);
			} 
	
		}
		result.push_back(vec);
	}
	return result;
    }
};

力扣 104.二叉树的最大深度

可以使用二叉树层序遍历来解决

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
         queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result=0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                 
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result++;
        }
        return result;
    }
};

力扣 226.翻转二叉树

使用前序遍历每一个节点的左右孩子交换一下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
	if(root==NULL) return root;
	swap(root->left,root->right);
	invertTree(root->left);
	invertTree(root->right);
	return root;
    }
};

力扣 101. 对称二叉树

本题遍历只能是后序遍历，比较的是两个子树的里侧和外侧的元素是否相等
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
	bool t(TreeNode *left,TreeNode *right){
		if(left==NULL&&right!=NULL) return false;
		else if(left!=NULL&&right==NULL) return false;
		else if(left==NULL&&right==NULL) return true;
		else if(left->val!=right->val) return false;
		
			bool a=t(left->left,right->right);
			bool b=t(left->right,right->left);
			bool c;
			return c=a&&b;
		
	}
    bool isSymmetric(TreeNode* root) {
	if(root==NULL) return true;
	return t(root->left,root->right);
    }
};

2301_79917093
关注
哈希表总结点睛
linping_的博客
04-23 971
哈希表 又称 散列表、 Hash table。哈希表就是根据关键吗的值而直接进校访问的数据结构 其实数组就是一张哈希表，数组的索引为key，数组的元素为value。 数据规模是dataSize， 哈希表的大小为tableSize 哈希表能解决什么问题呢？ 一般是用来快速判断一个元素是否出现集合里。 哈希碰撞有两种解决办法： 1、拉链法：拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。 2、线性探测法：使用线性探测法，一定要保证tab
哈希表+字符串
weixin_61518137的博客
08-30 390
首先每一次先固定一个数left，然后从这个数(不包含array[left])后面找到right下标的数使得array[left]+array[right]==target，是需要将nums[left]后面的数(不包括nums[left])的数全部加入到哈希表中，如果是这样的话，是需要一开始将所有的数都加入到哈希表中，[2，4，5，8]，target=8，此时再来进行模拟就可能找到两个4相加等于8，可能自己找到自己了，4.3)但数据范围小的时候:1-10^2~3~4~4~5，但是当出现负数不建议使用数组。
第七章 哈希表与字符串
Stay Hungry Stay Foolish 求知若饥 虚心若愚
08-23 2634
文章目录哈希表与字符串哈希表基础知识HashMap 基本使用leetcoe例1：最长回文串（409）例2：词语模式（290）例3：同字符词语分组（49）例4：无重复字符的最长子串（3）例5：重复的DNA序列（187）例6：最小窗口子串（76）剑指offer 哈希表与字符串 哈希表基础知识 哈希表（Hash table，也叫散列表），是根据关键字（key）直接进行访问的数据结构，它通过把关键值映射到...
【数据结构与算法】哈希表——字符串匹配
最新发布
qq_74047911的博客
08-13 375
跟原来一样,只不过关键码的类型不在是整型了,c++中的字符串是const char*,所以这里用的const void*.原来我们讲的都是以整数作为关键码,那么我们可不可以用字符串来作为关键码呢?可以将不同的字符串转换成为不同的数字,就方便我们进行取余分组了.这是关键码的类型改变了一下,其他都一样,就不讲了.答案是基本思想还是不变,哈希函数求余来进行分组.那么如果我们也想用哈希表存储,我们该怎么办呢?那么就需要我们进行转换了,就是大名鼎鼎的。有的时候我们希望能够很快的查找字符串.但是字符串怎么可能求取呢?
【字符串】Hash表
SY奇星的OI博客
04-01 372
指的是当两个或多个不同的数据具有相同的哈希值时发生的现象hash是处理字符串问题中不可缺少的元素，具体应用见下一期：hash表的应用。
❤数据结构❤——字符串哈希表
向梦想前进
10-02 618
字符串哈希 简介 字符串哈希表全称前缀哈希表，将字符串通过hash函数变成一个p进制的数，使不同的字符串映射到不同的数字上。例如：ABCD字符串，公式为 注意点 任何字符都不能映射成0，否则会出现不同的字符串都映射到0的情况。例如：“A”,"AA"等。 冲突：关于字符串哈希的方式，前人找到如果将P设为131或者13331，Q取2（64），产生冲突的概率及其小，大概十几亿分之一，这里我们认为我们人品足够好，比赛时不会产生冲突 步骤 用公式存放每一个字符串的hash值
acwing-841.字符串哈希
weixin_43211195的博客
04-19 442
题目描述 给定一个长度为 n 的字符串，再给定 m 个询问，每个询问包含四个整数 l1,r1,l2,r2，请你判断 [l1,r1] 和 [l2,r2] 这两个区间所包含的字符串子串是否完全相同。 字符串中只包含大小写英文字母和数字。 输入格式 第一行包含整数 n 和 m，表示字符串长度和询问次数。 第二行包含一个长度为 n 的字符串，字符串中只包含大小写英文字母和数字。 接下来 m 行，每行包含四个整数 l1,r1,l2,r2，表示一次询问所涉及的两个区间。 注意，字符串的位置从 1 开始编号。 输出格式
dataStructuresWith[removed]数组，字符串，哈希表，链接列表，堆栈，队列，树和图
04-13
本篇将深入探讨数组、字符串、哈希表、链表、堆栈、队列、树以及图这八大数据结构，并结合JavaScript进行讲解。 1. **数组**：数组是最基本的数据结构，它存储一组相同类型的元素。在JavaScript中，数组是一种动态...
C语言中压缩字符串的简单算法小结
09-02
例如，给定函数`HashString(const char *pString, unsigned long tableSize)`，它将字符串的每个字符累加，然后取模以适应tableSize大小的哈希表。这种方法简单但可能会导致较大的字符串无法充分利用散列表，造成...
C++股票信息查询系统源代码，实现多种查询排序算法KMP算法、二叉树、哈希表等，C++课程设计
02-13
KMP（Knuth-Morris-Pratt）算法是一种字符串匹配算法，用于在一个文本串中查找一个模式串。在股票信息查询系统中，可能用于快速定位特定股票代码或名称。KMP的优势在于避免了不必要的字符比较，提高了搜索效率，...
面试算法宝典之哈希表和集合
故事凌
09-17 553
1. 基本概念1. 哈希表我们先来看一下什么是哈希表散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映...
哈希表--关键字字符串
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);
哈希表（模拟散列表 字符串哈希）
咸鱼势力登场
05-28 1037
一、哈希表的概念 二、模拟散列表(①拉链法 ②开放寻址法) 三、字符串哈希
哈希表（Hash Table） -- 用数组模拟--字符串前缀哈希
cookies_s_的博客
04-01 1071
哈希表（Hash Table）是一种数据结构，用于存储键值对。它通过将键映射到表中的一个位置来实现快速的查找操作。在哈希表中，每个键都会经过一个哈希函数的计算，得到对应的哈希值，然后将键值对存储在哈希值对应的位置上。哈希表的主要特点包括：1. 快速的查找操作：通过哈希函数计算出键对应的位置，可以在常数时间内找到对应的值。2. 空间效率高：可以根据实际情况动态调整哈希表的大小，使得空间利用率高。
哈希表与字符串
yhy_13s的博客
05-07 483
字符哈希 哈希表排序整数 拉链法解决冲突，使用头插法 一，最长回文串 1.用数组实现哈希：即下标为key，对应的值为value 2.是否有中心点，及其计算，比较讨巧 class Solution { public: int longestPalindrome(string s) { int char_map[128]={0}; int max_length=0; int flag=0;//是否有中心点 for(int i=0;i<
字符串哈希
weixin_55812984的博客
11-26 1005
给定一个长度为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...
哈希表与字符串哈希
solego’s blog
07-18 935
哈希表是一种非常带劲的存储方法，它将一定个数内的数据以一种降低数据规模的方式存储着，哈希表的主要操作就是添加数据和查找数据，当然你也可以用标记来标记数据是否被删除（实际上，它只是被你标记删除了，并未被实际删除并释放内存） 上模板题让我们直观感受下： Acwing840 模拟散列表：传送门 ：https://www.acwing.com/problem/content/842/ 这题就让我...
哈希表（字符串哈希）
m0_62593364的博客
02-11 682
如何求字符串哈希？ 举例子：求字符串"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^
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值