数据结构--LeetCode专题练习 Day6

387. 字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

示例：

s = "leetcode"
返回 0

s = "loveleetcode"
返回 2
提示：你可以假定该字符串只包含小写字母。

原始思路：

1.字符串转为数组

2.建立hash表记录每个字母的次数

3.输出hash表中下标为1的第一个字母

class Solution {
public:
    int firstUniqChar(string s) {
		unordered_map<int,int>frequency;
		for(int i=0;i<s.size();i++){
			char ch=s[i];
			++frequency[ch];//记录频率
		}
		for(int i=0;i<s.size();i++){
			if(frequency[s[i]]==1){
				return  i;
			}
		}
		return -1;
	}
};

其他思路：

1.使用哈希表存储索引

使得第二次遍历的对象从字符串变为哈希映射
哈希映射中的每一个键值对，键表示一个字符，值表示它的首次出现的索引（如果该字符只出现一次）或者 -1（如果该字符出现多次）
（1）第一次遍历字符串时，设当前遍历到的字符为 c.
（2）如果 c 不在哈希映射中，就将 c与它的索引作为一个键值对加入哈希映射中，否则将 c 在哈希映射中对应的值修改为 -1。
（3）第一次遍历结束后，只需要再遍历一次哈希映射中的所有值，找出其中不为 -1的最小值，即为第一个不重复字符的索引。
ps.如果哈希映射中的所有值均为 -1，就返回 -1

class Solution {
public:
    int firstUniqChar(string s) {
        unordered_map<int, int> position;
        int n = s.size();
        for (int i = 0; i < n; ++i) {
            if (position.count(s[i])) {
                position[s[i]] = -1;
            }
            else {
                position[s[i]] = i;
            }
        }
        int first = n;
        for (auto [_, pos]: position) {
            if (pos != -1 && pos < first) {
                first = pos;
            }
        }
        if (first == n) {
            first = -1;
        }
        return first;
    }
};

2.队列

对字符串进行遍历，如果该字符不在hash表中，就将它与它的索引作为二元组放入队列尾部
如果在hash表中，检查队列中的元素是否都满足“只出现过1次”的要求
根据哈希映射中存储的值（是否为 -1）选择弹出队首的元素
直到队首元素只出现了一次或者队列为空

在遍历完成后，如果队列为空，说明没有不重复的字符，返回 -1，
否则队首的元素即为第一个不重复的字符以及其索引的二元组。

class Solution {
public:
    int firstUniqChar(string s) {
		unordered_map<char,int>position;//hash表
		queue<pair<char,int>>q;//队列
		int n=s.size();
		for(int i=0;i<n;i++){
			if(!position.count(s[i])){
				position[s[i]]=i;//下标
				q.emplace(s[i],i);//将“数值和下标”存入队列
			}else{
				position[s[i]]=-1;
				while(!q.empty()&&position[q.front().first]==-1){
					q.pop();
				}
			}
		}
		return q.empty() ?-1:q.front().second;
	}
};

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false
示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false
示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

提示：

你可以假设两个字符串均只含有小写字母。

原始思路：

magazine字符串是否包含ransom字符串//分别使用两个指针定位

时间复杂度: O(n^2)  ，空间复杂度：O(1)

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        for (int i = 0; i < magazine.length(); i++) {
            for (int j = 0; j < ransomNote.length(); j++) {
                // 在ransomNote中找到和magazine相同的字符
                if (magazine[i] == ransomNote[j]) { 
                    ransomNote.erase(ransomNote.begin() + j); // ransomNote删除这个字符
                    break;
                }
            }
        }
        // 如果ransomNote为空，则说明magazine的字符可以组成ransomNote
        if (ransomNote.length() == 0) { 
            return true;
        }
        return false;
    }
};//24ms  8.6MB

其他思路：

字典计数法（哈希策略）

用一个长度为26的数组还记录magazine里字母出现的次数，

然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
		int record[26]={0};
		for(int i=0;i<magzine.size();i++){
			record[magzine[i]-'a']++;//记录magazine中各个字符的出现次数
		}
		for(int j=0;j<ransomNote.size();j++){
			record[ransomNote[j]-'a']--;  //遍历验证ransomNote中是否包含其所需字母
			if(record[ransomNote[j]-'a']<0){  //小于零说明 magazine里出现的字符，ransomNote没有
				return false;
			}
		}
		return true;
	}
}; //8ms  8.3MB

242. 有效的字母异位词

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。示例 1:

输入: s = "anagram", t = "nagaram"
输出: true
示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

原始思路：

1.记录s中每个字母的次数 2.遍历验证t--，等于0则说明互异

class Solution {
public:
    bool isAnagram(string s, string t) {
         if (s.size() != t.size()) {
            return false;
        }
        int record[26]={0};
        for(int i=0;i<s.size();i++){
            record[s[i]-'a']++;
            record[t[i]-'a']--;
        }
        for(int j=0;j<26;j++){
            if(record[j]!=0){
                return false;
            }
        }
           return true;
    }
};//0 ms 7MB

其他思路：

排序

//对字符串s和t分别排序，长度不等一定不互异，长度相等后判断字符串是否相等

class Solution {
public:
    bool isAnagram(string s, string t) {
		if(s.size()!=t.size()){
			return false;
		}
		sort(s.begin(),s.end());
		sort(t.begin(),t.end());
		return s==t;
	}
};