大家好!下面是我(一个小小的搬运工)在秋招的时候在Leetcode上整理的一些二叉树的题目(中等难度),笔试和面试考相似思路题目的概率比较大,大家如果准备春秋季招聘可以先根据这些题目复习(具体思路可以看Leetcode中的讲解——困难的题有链接):
//2019_04_27
// 定义二叉树结构
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
//1、层序遍历二叉树 用一个vector存储每一层的数值,另一个vector<vector> 存储所有的
class Solution {
public:
vector<vector<int> > levelOrder(TreeNode *root) {
vector<vector<int>>result;
queue<TreeNode*>current, next;
if (root == nullptr)return result;
current.push(root);
while (!current.empty()){
vector<int>level;
while (!current.empty()){
TreeNode* node = current.front();
current.pop();
level.push_back(node->val);
if (node->left != nullptr)next.push(node->left);
if (node->right != nullptr)next.push(node->right);
}
result.push_back(level);
swap(current, next);
}
return result;
}
};
//2019_05_03
//1、给定一个数组(扩展:若数组无序则可先进行排序),其中元素按升序排序,将其转换为高度平衡的二叉搜索树
/*
* 这道题是二分查找树的题目,要把一个有序数组转换成一颗二分查找树。
* 从本质来看,如果把一个数组看成一棵树(也就是以中点为根,左右为左右子树,依次下去)
* 数组就等价于一个二分查找树。
* 所以如果要构造这棵树,那就是把中间元素转化为根,然后递归构造左右子树。
* 所以我们还是用二叉树递归的方法来实现,以根作为返回值,每层递归函数取中间元素,
* 作为当前根和赋上结点值,然后左右结点接上左右区间的递归函数返回值。
* 时间复杂度还是一次树遍历O(n),
* 总的空间复杂度是栈空间O(logn)加上结果的空间O(n),额外空间是O(logn),总体是O(n)。
*/
class Solution {
public:
TreeNode *tobst(vector<int > &num,int pre,int post)
{
if(pre==post)
return NULL;
int mid=(pre+post)/2; //int mid=left+(right-left+1)/2;(可防止溢出)
TreeNode *root=new TreeNode(num[mid]);
root->left=tobst(num,pre,mid);
root->right=tobst(num,mid+1,post);
return root;
}
TreeNode *sortedArrayToBST(vector<int> &num) {
return tobst(num,0,num.size());
}
};
//2、给定一棵二叉树,判断其是否镜像对称(即镜像二叉树) 警告:不能用中序遍历来判断{1,2,3,3,#,2,#}
class Solution {
public:
bool isSymmetric(TreeNode *root) {
return solv( root, root );
}
bool solv( TreeNode* p1, TreeNode* p2 ){
if( !p1 && !p2 )
return true;
else if( !p1 )
return false;
else if( !p2 )
return false;
if( p1->val != p2->val )
return false;
else
return solv(p1->left, p2->right) && solv(p1->right, p2->left);
}
};
//2019_05_07
//1、定义一棵多叉树,并进行深度优先遍历和广度优先遍历 (广联达面试——设计一个文件系统,并且打印出文件名) 深度遍历代码可能有问题!!!
class Node { //多叉树的定义!!! 常用于文件系统!!!
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
vector<int> res;
vector<vector<int> > ans;
bfs(root,res,ans);
return ans;
}
void bfs(Node* root,vector<int> &res,vector<vector<int> > &ans)
{
queue<Node*> tmp1;
queue<Node*> tmp2;
if(!root)return;
Node* tmp;
tmp1.push(root);
while(!tmp1.empty()||!tmp1.empty())
{
while(!tmp1.empty()){
tmp=tmp1.front();
tmp1.pop();
res.push_back(tmp->val);
int k = tmp->children.size();
int i=0;
while(k--)
{
tmp2.push(tmp->children[i++]);
}
}
ans.push_back(res);
res.clear();
swap(tmp1,tmp2);
}
}
};
//2、判断两个二叉树是否相等
class Solution {
public:
bool isSameTree(TreeNode *p, TreeNode *q) {
if ((p == nullptr)&&(q == nullptr))
return true;
else if ((q == nullptr) || (p == nullptr))
return false;
else if (p->val != q->val)
return false;
return (isSameTree(p->left, q->left)&&isSameTree(p->right, q->right));
}
};
//2、判断一棵树是否是二叉搜索树
class Solution {
public:
bool isValidBST(TreeNode *root) {
if(root == NULL)
return true;
if(root->left)
if(findRight(root->left)->val >= root->val)
return false;
if(root->right)
if(findLeft(root->right)->val <= root->val)
return false;
return isValidBST(root->left)&&isValidBST(root->right);
}
TreeNode* findLeft(TreeNode *root){
while(root->left){
root=root->left;
}
return root;
}
TreeNode* findRight(TreeNode *root){
while(root->right){
root=root->right;
}
return root;
}
};
//2019_05_09
//1、将二叉树的每一层节点从左向右链接起来,每层的最后一个节点指向空节点
struct TreeLinkNode {
int val;
TreeLinkNode *left, *right, *next;
TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
};
1 -> NULL
/ \
2 -> 3 -> NULL
/ \ \
4-> 5 -> 7 -> NULL
class Solution {
public:
void connect(TreeLinkNode *root) {
if(root==NULL) return;
queue<TreeLinkNode*> que;
que.push(root);
while(!que.empty()){
int n=que.size();
for(int i=0;i<n;i++){
TreeLinkNode* t=que.front(); que.pop();
if(t->left!=NULL) que.push(t->left);
if(t->right!=NULL) que.