二叉树相关面试题
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 minDepth(TreeNode* root)
{
int Depth = 0;
int Tmp = 1;
MinDepth(root,Depth,Tmp);
return Depth;
}
int MinDepth(TreeNode* root,int& Depth,int Tmp)
{
if(root)
{
if(root->left == NULL && root->right == NULL)
Depth = (Depth==0)?Tmp:(Tmp<Depth?Tmp:Depth);
MinDepth(root->left,Depth,Tmp+1);
MinDepth(root->right,Depth,Tmp+1);
return Depth;
}
return 0;
}
};
/*解法二*/
class Solution
{
public:
int minDepth(TreeNode* root)
{
if(!root)
return 0;
else if (!root->left && root->right)
return 1 + minDepth(root->right);
else if (!root->right && root->left)
return 1 + minDepth(root->left);
else return 1 + min(minDepth(root->left), minDepth(root->right));
}
};
2.按照层次打印二叉树
递归的方式：
/**
* 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:
vector<vector<int>> levelOrder(TreeNode* root)
{
vector<vector<int>> Vector;
int Level = 0;
LevelOrderBottom(root,Vector,Level);
return Vector;
}
void LevelOrderBottom(TreeNode* root,vector<vector<int>>& Vector,int Level)
{
if(root)
{
++Level;
if(Level > Vector.size())
Vector.resize(Level);
Vector[Level-1].push_back(root->val);
LevelOrderBottom(root->left,Vector,Level);
LevelOrderBottom(root->right,Vector,Level);
}
}
};
非递归的方式：（利用两个队列）
/**
* 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:
vector<vector<int>> levelOrder(TreeNode* root)
{
vector<vector<int>> Vector;
queue<TreeNode*> CurLevel;
int Level = 1;
if(root)
CurLevel.push(root);
while(!CurLevel.empty())
{
queue<TreeNode*> NextLevel;
while(!CurLevel.empty())
{
if(Level > Vector.size())
Vector.resize(Level);
TreeNode* root = CurLevel.front();
CurLevel.pop();
Vector[Level-1].push_back(root->val);
if(root->left)
NextLevel.push(root->left);
if(root->right)
NextLevel.push(root->right);
}
++Level;
CurLevel = NextLevel;
}
return Vector;
}
};
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:
vector<vector<int>> zigzagLevelOrder(TreeNode* root)
{
vector<vector<int>> Vector;
int Level = 1;
ZigzagLevelOrder(Vector,root,Level);
for(int i=0;i<Vector.size();++i)
{
if(i&1)
{
vector<int>::iterator it_begin = Vector[i].begin(),it_end = Vector[i].end();
reverse(it_begin,it_end);
}
}
return Vector;
}
void ZigzagLevelOrder(vector<vector<int>>& Vector,TreeNode* root,int Level)
{
if(root)
{
if(Level > Vector.size())
Vector.resize(Level);
Vector[Level-1].push_back(root->val);
ZigzagLevelOrder(Vector,root->left,Level+1);
ZigzagLevelOrder(Vector,root->right,Level+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:
vector<vector<int>> zigzagLevelOrder(TreeNode* root)
{
vector<vector<int>> Vector;
bool Order = true;
int Level = 1;
stack<TreeNode*> CurLevel;
if(root)
CurLevel.push(root);
while(!CurLevel.empty())
{
stack<TreeNode*> NextLevel;
while(!CurLevel.empty())
{
TreeNode* root = CurLevel.top();
CurLevel.pop();
if(Level > Vector.size())
Vector.resize(Level);
Vector[Level-1].push_back(root->val);
if(Order)
{
if(root->left)
NextLevel.push(root->left);
if(root->right)
NextLevel.push(root->right);
}
else
{
if(root->right)
NextLevel.push(root->right);
if(root->left)
NextLevel.push(root->left);
}
}
Level++;
Order = !Order;
CurLevel = NextLevel;
}
return Vector;
}
};
4.二叉树转换为单链表
/**
* 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 flatten(TreeNode* root)
{
if(root)
{
flatten(root->right);
flatten(root->left);
if(root->left)
{
TreeNode* tmp = root->left;
while(tmp->right)
tmp = tmp->right;
tmp->right = root->right;
root->right = root->left;
root->left = NULL;
}
}
}
};
5.二叉树的右视图
/**
* 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:
vector<int> rightSideView(TreeNode* root)
{
vector<int> Vector;
int MaxLevel = 0,CurLevel = 1;
RightSideView(root,Vector,MaxLevel,CurLevel);
return Vector;
}
void RightSideView(TreeNode* root,vector<int>& Vector,int& MaxLevel,int CurLevel)
{
if(root)
{
if(CurLevel > MaxLevel)
{
MaxLevel = CurLevel;
Vector.push_back(root->val);
}
RightSideView(root->right,Vector,MaxLevel,CurLevel+1);
RightSideView(root->left,Vector,MaxLevel,CurLevel+1);
}
}
};
6.判断能否构成二叉树
void Check(string& preorder, int& index, bool& Post)
{
if (preorder[index] != '\0')
{
bool left = false, right = false;
if (preorder[index++] == '#')
{
Post = true;
return;
}
Check(preorder, index, left);
Check(preorder, index, right);
Post = left && right;
}
}
bool isValidSerialization(string preorder)
{
bool Post = false;
int index = 0;
Check(preorder, index, Post);
if (index == preorder.size());
return Post;
return false;
}
解法二：
