秋招/春招常见笔试题目——二叉树系列(C/C++)

        大家好！下面是我(一个小小的搬运工)在秋招的时候在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.