226. 翻转二叉树
把二叉树遍历的输出节点改为交换左右孩子。
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
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:
void preOrder(TreeNode *root){
if(!root) return;
swap(root->left, root->right);
preOrder(root->left);
preOrder(root->right);
}
TreeNode* invertTree(TreeNode* root) {
preOrder(root);
return root;
}
};
迭代
// 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:
void preOrder(TreeNode *root){
if(!root) return;
swap(root->left, root->right);
preOrder(root->left);
preOrder(root->right);
}
TreeNode* invertTree(TreeNode* root) {
if(!root) return root;
TreeNode* p = root;
stack<TreeNode*> st;
st.push(root);
while(!st.empty()){
p = st.top();
st.pop();
swap(p->left, p->right);
if(p->left) st.push(p->left);
if(p->right) st.push(p->right);
}
return root;
return root;
}
};
101. 对称二叉树
把问题划分成子问题,判断是否对称,就是最外侧的和最外侧的比,最内侧的和最内侧的比,也就是左子树的左子树和右子树的右子树比,左子树的右子树和右子树的左子树比。
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
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:
bool compare(TreeNode* left, TreeNode* right){
if(!left && right) return false;
if(left && !right) return false;
if(!left && !right) return true;
if(left->val != right->val) return false;
bool out = compare(left->left, right->right);
bool in = compare(left->right, right->left);
return in && out;
}
bool isSymmetric(TreeNode* root) {
if(!root) return true;
return compare(root->left, root->right);
}
};
迭代
// 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:
bool isSymmetric(TreeNode* root) {
queue<TreeNode*> que;
if(!root) return true;
que.push(root->left);
que.push(root->right);
while(!que.empty()){
TreeNode* left = que.front();
que.pop();
TreeNode* right = que.front();
que.pop();
if(!left && !right) continue;
if((!left || !right || (left->val != right->val))) return false;
que.push(left->left);
que.push(right->right);
que.push(left->right);
que.push(right->left);
}
return true;
}
};
104. 二叉树的最大深度
把二叉树遍历的过程中计算层数。
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
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:
int preOrder(TreeNode* root){
if(!root) return 0;
int left = preOrder(root->left) + 1;
int right = preOrder(root->right) + 1;
return left>right? left:right;
}
int maxDepth(TreeNode* root) {
return preOrder(root);
}
};
层序迭代
// 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:
int maxDepth(TreeNode* root) {
queue<TreeNode*> que;
if(!root) return 0;
que.push(root);
int depth = 0;
while(!que.empty()){
int size = que.size();
depth++;
for(int i=0; i<size; i++) {
root = que.front();
que.pop();
if(root->left)que.push(root->left);
if(root->right) que.push(root->right);
}
}
return depth;
}
};
111. 二叉树的最小深度
与求最大深度类似,但需要注意一个问题,不能直接取左右子树的最小层数返回,如果是一颗斜树(只有一侧有子树)就会出错,因为这里要求的是到业结点的最小层数,所以在返回层数做判断,若是斜树,则返回最大层数,反之返回最小层数。
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
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:
int preOrder(TreeNode * root){
if(!root) return 0;
int left = preOrder(root->left) + 1;
int right = preOrder(root->right) + 1;
// 斜树取最大 这里会把叶结点也包含在内 但是叶结点的层数恒为1不受影响
if(!root->left || !root->right)
return left>right?left:right;
// 满树取最小
return left<right?left:right;
}
int minDepth(TreeNode* root) {
return preOrder(root);
}
};
迭代
// 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:
int minDepth(TreeNode* root) {
if(!root) return 0;
queue<TreeNode*> que;
que.push(root);
int depth=0;
while(!que.empty()){
int size = que.size();
depth++;
for(int i=0; i<size; i++){
root = que.front();
que.pop();
if(root->left) que.push(root->left);
if(root->right) que.push(root->right);
if(!root->left && !root->right) return depth;
}
}
return depth;
}
};