二叉树进阶练习题，附详解，来做题喽~

如果对你有帮助，请一键三连（点赞+收藏+关注）哦~ 感谢支持！欢迎各位在评论区与博主友好讨论！缓慢更新中……

---

606. 根据二叉树创建字符串

根据示例可得，右边不为空，左边显示和左边不为空，右边为空时，右边不显示。

class Solution {
public:
    void test(TreeNode*root,string& s)
    {
        if(root==nullptr)
            return;
        s+=to_string(root->val);
        if(root->left||root->right)//左空右不空
        {
            s+='(';
            test(root->left,s);
            s+=')';
        }
        if(root->right)
        {
            s+='(';
            test(root->right,s);
            s+=')';
        }
    }

    string tree2str(TreeNode* root) {
//右边不为空，左边显示
//左边不为空，右边为空时，右边不显示
        string s;
        test(root,s);
        return s;
    }
};

---

102.二叉树的层序遍历 

使用队列，一层层进队列，先进先出。出一个，就入它的子树。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {

        queue<TreeNode*>q;
        int size=0;
        if(root)
        {
            q.push(root);
            size=1;
        }

        vector<vector<int>>b;
        while(!q.empty())//栈里还有
        {
            vector<int>a;//建立每一层数组
            while(size--)//控制每层输出的数据个数
            {
                TreeNode*f=q.front();
                q.pop();
                a.push_back(f->val);//进入每一层的数组
                if(f->left)
                {
                    q.push(f->left);
                }
                if(f->right)
                {
                    q.push(f->right);
                }
            }
            size=q.size();
            b.push_back(a);

        }
        return b;
    }
};

---

107.二叉树的层序遍历II

将上题结果逆置即可：reverse(b.begin(),b.end());

二维数组也可逆置！

---

236. 二叉树的最近公共祖先

会想起 找链表共同节点。路径长的先走，然后从一个节点开始找共同节点。

假设p为6，q为4。

先找到这两个节点，先左后右，入栈：

p先遍历左，直接就找到了：3->5->6

q先遍历左	3->5->6
6左右子树都没有，去除6	3->5
返回5，找5的右树2	3->5->2
2找左子树7	3->5->2->7
7左右子树都没有，返回2，删除7	3->5->2
找2的右子树4，找到了	3->5->2->4
返回2，返回5，返回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 findPath(TreeNode*root,TreeNode*x,stack<TreeNode*>&path)
    {
        if(root==NULL)
            return false;
        path.push(root);//先入栈
        if(root==x)
            return true;
        if(findPath(root->left,x,path))
            return true;
        if(findPath(root->right,x,path))
            return true;
        path.pop();//左右都没有就去除
        return false;

    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        stack<TreeNode*>p1,q1;
        findPath(root,p,p1);
        findPath(root,q,q1);
        while(p1.size()!=q1.size())
        {
            if(p1.size()>q1.size())
                p1.pop();
            else 
                q1.pop();
        }

        while(p1.top()!=q1.top())
        {
            p1.pop();
            q1.pop();
        }
        return q1.top();

    }
};

---

二叉搜索树与双向链表 

基本逻辑就是cur->left=prev;  prev->right=prev;  遍历完左，prev=cur，遍历右。

 

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void in(TreeNode*cur,TreeNode*&prev)
    {
        if(cur==nullptr)
            return;
        in(cur->left,prev);
        cur->left=prev;
        if(prev)
            prev->right=cur;
        prev=cur;
        
        in(cur->right,prev);
    }
    
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(pRootOfTree==nullptr)
            return nullptr;
        TreeNode*prev=nullptr;
        in(pRootOfTree,prev);
        TreeNode*head=pRootOfTree;
        while(head->left)
        {
            head=head->left;
        }
        return head;
    }
};