二叉树的进阶面试题（力扣leetcode、牛客）

最新推荐文章于 2022-12-05 22:20:35 发布

原创最新推荐文章于 2022-12-05 22:20:35 发布 · 261 阅读

0 ·

CC 4.0 BY-SA版权

数据结构学习同时被 3 个专栏收录

13 篇文章

订阅专栏

复习

11 篇文章

订阅专栏

程序员秋招准备！

8 篇文章

订阅专栏

本文深入探讨了二叉树在算法面试中的核心题目，包括字符串表示、分层遍历、最近公共祖先查找、转换为双向链表、根据遍历序列重建二叉树等，提供了详细的代码实现。

二叉树的基础面试题
1. 二叉树创建字符串

class Solution {
public:
    string preorder(TreeNode* root,string& s)
    {
        if (root == nullptr)
        {
            return s;
        }
        s += to_string(root->val);
        if (root->left != nullptr)
        {
            s += "(";
            s = preorder(root->left, s);
            s += ")";
        }

        if (root->right != nullptr)
        {
            if (root->left == nullptr)
            {
                s += "()";
            }
            s += "(";
            s = preorder(root->right, s);
            s += ")";
        }
        return s;
    }
    string tree2str(TreeNode* t) {
        string s="";
       return preorder(t,s);
    }
};

2. 二叉树的分层遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        vector<vector<int>> arr;
        if(root==nullptr)
            return arr;
        queue<TreeNode*> q;
        q.push(root);
       while(!q.empty())
        {
            vector<int> tmp;
            int size=q.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* node=q.front();
                q.pop();
                tmp.push_back(node->val);
                if(node->left) 
                    q.push(node->left);
                if(node->right) 
                    q.push(node->right);
            }
            arr.push_back(tmp);
        }
    return arr;
    }
};

3. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==nullptr)
            return root;
        if(root==p||root==q)
            return root;
        TreeNode *left = lowestCommonAncestor(root->left,p,q);
        TreeNode *right = lowestCommonAncestor(root->right,p,q);                 
        if(left!=nullptr&&right!=nullptr) 
            return root;//如果p,q刚好在左右两个子树上
        if(left==nullptr) 
            return right;//仅在右子树
        if(right==nullptr) 
            return left;//仅在左子树
        return nullptr;
    }
};

4. 二叉树搜索树转换成排序双向链表

class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
    if(pRootOfTree == nullptr) 
      return nullptr;

    TreeNode* pre = nullptr;
    ConvertInorder(pRootOfTree, pre);

    TreeNode* ret = pRootOfTree;
    while(ret ->left)
      ret = ret ->left;
    return ret;
    }
    void ConvertInorder(TreeNode* cur, TreeNode*& pre)
    {
      if(cur == nullptr) 
        return;

      ConvertInorder(cur ->left, pre);

      cur ->left = pre;
      if(pre) 
        pre ->right = cur;
      pre = cur;

      ConvertInorder(cur ->right, pre);
    }
};

5. 根据一棵树的前序遍历与中序遍历构造二叉树

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0)
            return nullptr;
        int n=0;
        while(inorder[n]!=preorder[0])
        {
            n++;
        }
        TreeNode* root=new TreeNode(preorder[0]);
        vector<int> preleft(preorder.begin()+1,preorder.begin()+n+1);//左前序
        vector<int> preright(preorder.begin()+n+1,preorder.end());//右前序
        vector<int> inleft(inorder.begin(),inorder.begin()+n);//左中序
        vector<int> inright(inorder.begin()+n+1,inorder.end());//右中序
        root->left=buildTree(preleft,inleft);
        root->right=buildTree(preright,inright);
        return root;
    }
};

6. 根据一棵树的中序遍历与后序遍历构造二叉树

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int size=postorder.size();
        if(size==0)
            return nullptr;
        int n=0;
        while(inorder[n]!=postorder[size-1])
        {
            n++;
        }
        TreeNode* root=new TreeNode(postorder[size-1]);
        vector<int> postleft(postorder.begin(),postorder.begin()+n);//左后序
        vector<int> postright(postorder.begin()+n,postorder.end()-1);//右后序
        vector<int> inleft(inorder.begin(),inorder.begin()+n);//左中序
        vector<int> inright(inorder.begin()+n+1,inorder.end());//右中序
        root->left=buildTree(inleft,postleft);
        root->right=buildTree(inright,postright);
        return root;
    }
};

7. 二叉树的前序遍历，非递归迭代实现

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> arr;
        if(root==nullptr)
        {
            return arr;
        }
        stack<TreeNode*> s;
        TreeNode* node=root;
        while(!s.empty()||node)
        {
            while(node)
            {
                s.push(node);
                arr.push_back(node->val);
                node=node->left;
            }
            if(!s.empty())
            {
                node=s.top();
                s.pop();
                node=node->right;
            }
        }
        return arr;
    }
};

8. 二叉树中序遍历，非递归迭代实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> arr;
        if(root==nullptr)
        {
            return arr;
        }
        stack<TreeNode*> s;
        TreeNode* node=root;
          while(!s.empty()||node)
        {
            while(node)
            {
                s.push(node);
                node=node->left;
            }
            if(!s.empty())
            {
                node=s.top();
                s.pop();
                arr.push_back(node->val);
                node=node->right;
            }
        }
        return arr;
    }
};

9. 二叉树的后序遍历，非递归迭代实现

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
       vector<int> arr;
        if(root==nullptr)
        {
            return arr;
        }
        stack<TreeNode*> s;
        TreeNode* node=root;
        TreeNode* ret=nullptr;
        while(!s.empty()||node)
        {
           if(node)
           {
               s.push(node);
               node=node->left;
           }
            else
            {
                node=s.top();
                if(node->right!=nullptr&&node->right!=ret)
                    node=node->right;
                else
                {
                    s.pop();
                    arr.push_back(node->val);
                    ret=node;
                    node=nullptr;
                }
            }
        }
        return arr;
    }
};