持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第23天，点击查看活动详情
208. 实现 Trie (前缀树)
思路
字典树
字典树，顾名思义，是关于“字典”的一棵树。即：它是对于字典的一种存储方式（所以是一种数据结构而不是算法）。这个词典中的每个“单词”就是从根节点出发一直到某一个目标节点的路径，路径中每条边的字母连起来就是一个单词。
标橙色的节点是“目标节点“，即根节点到这个目标节点的路径上的所有字母构成了一个单词。
作用：
- 1、维护字符串集合 （字典）
- 2、向字符串集合中插入字符串 （建树）
- 3、查询字符串集合中是否有某个字符串 （查询）
- 4、查询字符串集合中是否有某个字符串的前缀 （查询）
具体操作：
定义字典树节点
struct Node {
bool is_end; // 表示是否存在以这个点为结尾的单词
Node *son[26]; // 26个小写字母子结点
Node() { // 初始化
is_end = false;
for (int i = 0; i < 26; i ++ )
son[i] = NULL;
}
}*root;
向字典树中插入一个单词word
从根结点出发，沿着字符串的字符一直往下走，若某一字符不存在，则直接把它创建出来，继续走下去，走完了整个单词，标记最后的位置的is_end = true。
void insert(string word) {
auto p = root;
for (auto c: word) {
int u = c - 'a';
if (!p->son[u]) p->son[u] = new Node();
p = p->son[u];
}
p->is_end = true;
}
查找字典树中是否存在单词word
从根结点出发，沿着字符串的字符一直往下走，若某一字符不存在，则直接return false，当很顺利走到最后的位置的时候，判断最后一个位置的is_end即可。
bool search(string word) {
auto p = root;
for (auto c: word) {
int u = c - 'a';
if (!p->son[u]) return false;
p = p->son[u];
}
return p->is_end;
}
查找字典树中是否有以prefix为前缀的单词
从根结点出发，沿着字符串的字符一直往下走，若某一字符不存在，则直接return false，如果顺利走到最后一个位置，则返回true。
bool startsWith(string word) {
auto p = root;
for (auto c: word) {
int u = c - 'a';
if (!p->son[u]) return false;
p = p->son[u];
}
return true;
}
时间复杂度分析： O(n)，n表示单词操作字符串长度。
c++代码
class Trie {
public:
struct Node{
bool is_end;
Node *son[26];
Node(){
is_end = false;
for(int i = 0; i < 26; i++)
son[i] = NULL;
}
}*root;
Trie() {
root = new Node();
}
void insert(string word) {
auto p = root;
for(auto c : word){
int u = c - 'a';
if(!p->son[u]) p->son[u] = new Node();
p = p->son[u];
}
p->is_end = true;
}
bool search(string word) {
auto p = root;
for(auto c : word){
int u = c - 'a';
if(!p->son[u]) return false;
p = p->son[u];
}
return p->is_end;
}
bool startsWith(string prefix) {
auto p = root;
for(auto c : prefix){
int u = c -'a';
if(!p->son[u]) return false;
p = p->son[u];
}
return true;
}
};
/**
* Your Trie object will be instantiated and called as such:
* Trie* obj = new Trie();
* obj->insert(word);
* bool param_2 = obj->search(word);
* bool param_3 = obj->startsWith(prefix);
*/
221. 最大正方形
思路
(动态规划) O(nm)
状态表示： f[i][j]表示所有以(i,j)为右下角的且只包含1的正方形的边长最大值。
状态计算：
对于每个位置 (i, j)，检查在矩阵中该位置的值：
- 如果该位置的值是
0，则f[i][j] = 0，因为当前位置不可能在由1组成的正方形中。 - 如果该位置的值是
1，则f[i][j]的值由其上方、左方和左上方的三个相邻位置的状态值决定。具体而言，当前位置的元素值等于三个相邻位置的元素中的最小值加1。
状态转移方程： f[i,j] = min(f[i−1,j−1],f[i−1,j],f[i,j−1]) + 1
类似于 木桶的短板理论， 附近的最小边长，才与(i,j)的最长边长有关。
时间复杂度分析： O(nm)，其中 n和m是矩阵的行数和列数。
c++代码
class Solution {
public:
int maximalSquare(vector<vector<char>>& matrix) {
int n = matrix.size(), m = matrix[0].size();
if(!n || !m) return 0;
vector<vector<int>>f(n + 1, vector<int>(m + 1));
int res = 0;
for(int i = 1; i <= n; i++) //为了减少对边界的处理，这里我们下标从1开始
for(int j = 1; j <= m; j++)
if(matrix[i - 1][j - 1] == '1')
{
f[i][j] = min(f[i][j - 1], min(f[i - 1][j], f[i - 1][j - 1])) + 1;
res = max(res, f[i][j]);
}
return res * res;
}
};
226. 翻转二叉树
思路
(递归) O(n)
我们可以发现翻转后的树就是将原树的所有节点的左右儿子互换！
所以我们递归遍历原树的所有节点，将每个节点的左右儿子互换即可。
时间复杂度分析： 每个节点仅被遍历一次，所以时间复杂度是 O(n)。
c++代码
/**
* 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) return nullptr;
swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);
return root;
}
};
