101. Symmetric Tree\104. Maximum Depth of Binary Tree\111. Minimum Depth of Binary Tree

Symmetric Tree
题目描述

代码实现

Maximum Depth of Binary Tree
题目描述

代码实现

Minimum Depth of Binary Tree
题目描述

代码实现

101. Symmetric Tree

题目描述

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

1
/ \
2   2
/ \ / \
3  4 4  3

But the following [1,2,2,null,3,null,3] is not:

1
/ \
2   2
\   \
3    3

代码实现

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSym(TreeNode *l, TreeNode *r) {
if(l && r) {
if(l->val == r->val) {
if(isSym(l->right, r->left) && isSym(l->left, r->right))
return true;
else
return false;
}
else return false;
}
else if((!l && r) || (l && !r))
return false;
else
return true;
}

bool isSymmetric(TreeNode* root) {
if(root) {
return isSym(root->left, root->right);
}
else
return true;
}
};

104. Maximum Depth of Binary Tree

题目描述

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

代码实现

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void culMaxDepth(TreeNode *root, int &max_dep) {
if(!root) return;
else {
if(root->val > max_dep) max_dep = root->val;
if(root->left) {
root->left->val =  root->val + 1;
culMaxDepth(root->left, max_dep);
}
if(root->right) {
root->right->val = root->val + 1;
culMaxDepth(root->right, max_dep);
}
}
}

int maxDepth(TreeNode* root) {
int max_dep = 0;
if(root) {
root->val = 1;
culMaxDepth(root, max_dep);
}
return max_dep;
}
};

DFS的做法：一行搞定，简直diao

int maxDepth(TreeNode *root)
{
return root == NULL ? 0 : max(maxDepth(root -> left), maxDepth(root -> right)) + 1;
}

这里使用深度优先的算法，深度优先更加简单，更加容易实现。

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int maxDepth(TreeNode *root)
{
if(root == NULL) return 0;
int res = 0;
queue<TreeNode *> q;
q.push(root);
while(!q.empty()) {
++ res;
for(int i = 0, n = q.size(); i < n; ++ i) {
TreeNode *p = q.front(); q.pop();
if(p -> left != NULL) q.push(p -> left);
if(p -> right != NULL) q.push(p -> right);
}
}
return res;
}
};

111. Minimum Depth of Binary Tree

题目描述

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

代码实现

使用广度优先的算法

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode* root) {
int res = 0;
if(!root) return res;
queue<TreeNode*> tq;
tq.push(root);
while(!tq.empty()) {
res++;
int sz = tq.size();
for(int i = 0; i < sz; i++) {
TreeNode* tmp = tq.front();
tq.pop();
if(!tmp->left && !tmp->right) return res;
if(tmp->left) tq.push(tmp->left);
if(tmp->right) tq.push(tmp->right);
}
}

return res;
}
};

DFS的做法：

/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode *root) {
if(!root) return 0;
if(!root->left) return 1 + minDepth(root->right);
if(!root->right) return 1 + minDepth(root->left);
return 1+min(minDepth(root->left),minDepth(root->right));
}
};