二叉树的右视图
层次遍历，每次取出每一层的最后一个节点的值，加入到res即可。
/**
* 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<int> rightSideView(TreeNode* root) {
if(root == nullptr){
return {};
}
vector<int> res;
queue<TreeNode*> que;
que.push(root);
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);
}
if(i == size-1){
res.push_back(node->val);
}
}
}
return res;
}
};
二叉树的锯齿形层次遍历
/**
* 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>> zigzagLevelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root == nullptr){
return res;
}
queue<TreeNode *>que;
que.push(root);
bool flag = false;
while(!que.empty()){
int size = que.size();
vector<int> temp;
for(int i=0; i<size; i++){
TreeNode* node = que.front();
que.pop();
temp.push_back(node->val);
if(node->left){
que.push(node->left);
}
if(node->right){
que.push(node->right);
}
}
if(flag){
reverse(temp.begin(), temp.end());
}
flag = !flag;
res.push_back(temp);
}
return res;
}
};
二叉搜索树的最小绝对差
/**
* 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 inorder(TreeNode* root, vector<int>& arrs){
if(root == nullptr){
return;
}
inorder(root->left, arrs);
arrs.push_back(root->val);
inorder(root->right, arrs);
}
int getMinimumDifference(TreeNode* root) {
vector<int> arrs;
inorder(root, arrs);
int ret = INT_MAX;
for(int i=0; i<arrs.size()-1; i++){
ret = min(ret, abs(arrs[i] - arrs[i+1]));
}
return ret;
}
};
二叉搜索树中第k小的树
/**
* 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 inorder(TreeNode* root, vector<int>& arrs){
if(root == nullptr){
return;
}
inorder(root->left, arrs);
arrs.push_back(root->val);
inorder(root->right, arrs);
}
int kthSmallest(TreeNode* root, int k) {
vector<int> arrs;
inorder(root, arrs);
return arrs[k-1];
}
};
验证二叉搜索树
/**
* 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 helper(TreeNode* root, long long lower, long long upper){
if(root == nullptr){
return true;
}
if(root->val <= lower || root->val >= upper){
return false;
}
return helper(root->left, lower, root->val)&&helper(root->right, root->val, upper);
}
bool isValidBST(TreeNode* root) {
return helper(root, LONG_MIN, LONG_MAX);
}
};
岛屿数量
class Solution {
public:
void dfs(vector<vector<char>>& grid, int r, int c){
int nr = grid.size();
int nc = grid[0].size();
grid[r][c] = '0';
if(r-1 >= 0 && grid[r-1][c] == '1'){
dfs(grid, r-1, c);
}
if(r+1 < nr && grid[r+1][c] == '1'){
dfs(grid, r+1, c);
}
if(c-1 >= 0 && grid[r][c-1] == '1'){
dfs(grid, r, c-1);
}
if(c+1 < nc && grid[r][c+1] == '1'){
dfs(grid, r, c+1);
}
}
int numIslands(vector<vector<char>>& grid) {
int nr = grid.size();
if(!nr){
return 0;
}
int nc = grid[0].size();
int numIslands = 0;
for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++){
if(grid[i][j] == '1'){
dfs(grid, i, j);
numIslands++;
}
}
}
return numIslands;
}
};
被围绕的区域
给定一个mxn的矩阵board，由若干字符’X’和’O’组成，捕获所有被围绕的区域：
任何边界上的0不会被填充为X。
- 对于每一个边界上的0，我们以它为起点，标记所有与它直接或间接相连的字母O。
class Solution {
public:
int n,m;
void dfs(vector<vector<char>>& board, int x, int y){
if(x < 0 || x >= n || y < 0 || y >= m || board[x][y] != 'O'){
return;
}
board[x][y] = 'A';
dfs(board, x+1, y);
dfs(board, x-1, y);
dfs(board, x, y-1);
dfs(board, x, y+1);
}
void solve(vector<vector<char>>& board) {
n = board.size();
if(n == 0){
return;
}
m = board[0].size();
for(int i=0; i<n; i++){
dfs(board, i, 0);
dfs(board, i, m-1);
}
for(int j=0; j<m; j++){
dfs(board, 0, j);
dfs(board, n-1, j);
}
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
if(board[i][j] == 'A'){
board[i][j] = 'O';
}else if(board[i][j] == 'O'){
board[i][j] = 'X';
}
}
}
}
};
最小基因变化
基因序列可表示为一条由8个字符组成的字符串，每个字符都是A,C,G,T。
需要调查从start基因变为end基因的基因变化，一次基因变化就意味着一个字符发生变化。
变化后的基因必须位于bank中。
广度优先搜索
基因变化需要满足：
- A与B只有一个字符不同。
- 变化字符只能从A,C,G,T中选择。
- B一定要在bank中。
如果start与end相等，此时返回0，如果最终基因序列不在bank中，返回-1。
电话号码的字母组合
class Solution {
private:
vector<string> maps = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
public:
void dfs(vector<string>& res, string &digits, string& temp, int k, int &n){
if(k == n){
res.push_back(temp);
return;
}
int index = digits[k] - '0' -2;
string str = maps[index];
for(int j=0; j<str.size(); j++){
temp += str[j];
dfs(res, digits, temp, k+1, n);
temp.pop_back();
}
}
vector<string> letterCombinations(string digits) {
int n = digits.size();
if(n == 0){
return{};
}
vector<string> res;
string temp = "";
dfs(res, digits, temp, 0, n);
return res;
}
};
组合
class Solution {
public:
vector<int> temp;
vector<vector<int>> res;
void dfs(int cur, int n, int k){
//temp长度加上区间[cur,n]的长度小于k，不可能构造出长度为k的temp。
if(temp.size() + n-cur+1 < k){
return;
}
if(temp.size() == k){
res.push_back(temp);
return;
}
//选择当前位置
temp.push_back(cur);
dfs(cur+1, n, k);
//不考虑当前位置
temp.pop_back();
dfs(cur+1, n, k);
}
vector<vector<int>> combine(int n, int k) {
dfs(1, n, k);
return res;
}
};
全排列
class Solution {
public:
void dfs(vector<vector<int>> &res, vector<int>& nums, int index, int n){
if(index == n){
res.push_back(nums);
}
for(int i=index; i<n; i++){
swap(nums[i], nums[index]);
dfs(res, nums, index+1, n);
swap(nums[i], nums[index]);
}
}
vector<vector<int>> permute(vector<int>& nums) {
vector<vector<int>> res;
int n = nums.size();
vector<int> temp(n);
dfs(res, nums, 0, n);
return res;
}
};
二进制求和
1521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
