Aprende "Código Caprice"
conocimiento básico
Una tabla hash es una estructura de datos que accede directamente a los datos en función del valor de una clave. Generalmente se usa para determinar rápidamente si un elemento aparece en la colección.
función hash
hashCode puede convertir otros formatos de datos en diferentes valores a través de un formato de codificación específico. La función hash luego asigna estos valores a los índices de la tabla hash.
colisión de hash
Después de encontrar una colisión hash, hay dos soluciones:
método de cremallera: almacena los valores en conflicto en la lista vinculada en secuencia.
sondeo lineal: almacene el valor conflictivo en la siguiente vacante, por lo que debe asegurarse de que tableSize sea mayor que dataSize.
Tres estructuras hash
Ellos son: matriz, colección (conjunto), mapeo (mapa)
Cuando usamos colecciones para resolver problemas de hashing, se prefiere unordered_setporque tiene la mejor eficiencia de consulta y adición y eliminación;
Si se requiere ordenar la colección, utilícela set;
Si se requiere que la colección no solo sea ordenada, sino también que tenga datos repetidos, utilícela multiset.
La implementación subyacente del primero usa una tabla hash, mientras que los dos últimos usan un árbol rojo-negro
anagramas validos
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26] = {
0};
for (int i = 0; i < s.size(); i++) {
record[s[i] - 'a']++;
}
for (int i = 0; i < t.size(); i++) {
record[t[i] - 'a']--;
}
for (int i = 0; i < 26; i++) {
if (record[i] != 0) {
return false;
}
}
return true;
}
};
intersección de dos matrices
usarunordered_set
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set; // 保存结果
unordered_set<int> nums_set(nums1.begin(), nums1.end()); // 去重
for (int num : nums2) {
// find()查找该元素第一次出现的位置，end()指向末尾元素的下一个位置
if (nums_set.find(num) != nums_set.end()) {
// 说明找到了
result_set.insert(num); // 放入交集
}
}
return vector<int>(result_set.begin(), result_set.end()); // 这里用vector
}
};
suma de dos numeros
ley de violencia
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
for (int i = 0; i < nums.size(); i++) {
for (int j = i + 1; j < nums.size(); j++) {
if (nums[i] + nums[j] == target) {
return {
i, j};
}
}
}
return {
};
}
};
Complejidad del tiempo: O(n^2)
Mapa
En esta pregunta, no es bueno usar una matriz porque hay pocos elementos; tampoco es adecuado para un conjunto, porque un conjunto solo guarda una clave, pero necesitamos comparar valores y guardar subíndices al mismo tiempo .
Así que elija mapa, <clave, valor> usa clave para representar el valor y usa valor para registrar el subíndice.
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 iter = map.find(target - nums[i]); // auto 自己推演数据类型
if (iter != map.end()) {
// 找到一个
return {
i, iter->second}; // first表示key，second表示value
}
map.insert(pair<int, int>(nums[i], i)); // map<X,Y>实际存储的是pair<const X,Y>
}
return {
};
}
};
Complejidad temporal: O(n)
Añadir cuatro números
La fórmula original se puede transformar ennums1[i] + nums2[j] = -nums3[k] - nums4[l]
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map <int, int> umap;
for (int a : nums1) {
for (int b : nums2) {
umap[a + b]++;
}
}
// 找0 - (c + d)
int count = 0;
for (int c : nums3) {
for (int d : nums4) {
if (umap.find(0 - (c + d)) != umap.end()) {
count += umap[0 - (c + d)];
}
}
}
return count;
}
};
suma de tres numeros
solución de hash
El resultado de salida no coincide con el resultado esperado, ¿no es así? Comprobado uno por uno, sí
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for (int i = 0; i < nums.size(); i++) {
if (nums[i] > 0) break;
if (i > 0 && nums[i - 1] == nums[i]) {
// 元素a去重
continue;
}
unordered_set<int> set;
for (int j = i + 1; j < nums.size(); j++) {
if (j > i + 2 && nums[j - 2] == nums[j - 1] && nums[j - 1] == nums[j]) {
// 元素b去重
continue;
}
int c = 0 - (nums[i] + nums[j]);
if (set.find(c) != set.end()) {
result.push_back({
nums[i], nums[j], c});
set.erase(c); // 元素c去重
} else {
set.insert(nums[j]) // 不懂
}
}
}
return result;
}
};
método de doble puntero
No entiendo, déjalo ir.