重建二叉树——C++

剑指offer07：重建二叉树

题目重述：给出先序和中序，重建二叉树，以层序输出

按照自己的想法写了一通，在VS2022中可以跑通，但是算法效率不高，在leetcode上跑超时了，先给出自己的代码，再列出官解

自己的想法：

     重建二叉树部分采用了递归，主要的思路是先要找到中序输出数组中的元素在前序输出数组中最靠前的一位，并将该元素作为父节点。在中序输出数组中，以该元素为分界线，左边的数组为左子树组，右边的数组为右子树组，每一项子树又向上述方法一样分出父节点和子树。

     层序采用了左程云老师课上所说的采用队列先进先出的方法，头节点先进，当节点出队列的时候依次让左孩子和右孩子进入队列，直到队列为空

// ConstructBinaryTree.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 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:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (inorder.size() == 0)
            return nullptr;

        TreeNode* TNode = new TreeNode(0);
        int Mid = FindMiddleNum(preorder, inorder);
        TNode->val = Mid;
        vector<int> LeftArray = FindLeftArray(Mid, inorder);
        TNode->left = buildTree(preorder, LeftArray);
        vector<int> RightArray = FindRightArray(Mid, inorder);
        TNode->right = buildTree(preorder, RightArray);
        return TNode;
    }

    void SequenceTraversal(TreeNode* TNode)       //层序遍历
    {
        if (TNode == nullptr)
            return;
        queue<TreeNode*> Nodequeue;
        Nodequeue.push(TNode);
        while (Nodequeue.size()!=0)
        {
            TreeNode* Temp = Nodequeue.front();
            Nodequeue.pop();
            if (Temp != nullptr)
            {
                cout << Temp->val << ",";
                if (Nodequeue.size() == 1 && Temp->left == nullptr && Temp->right ==nullptr)
                    return;
                else
                {
                    Nodequeue.push(Temp->left);
                    Nodequeue.push(Temp->right);
                }
                
            }
            else
            cout << "null" << ",";

        }
    }


    vector<int> FindLeftArray(int& num, vector<int>& inorder)   //根据中值找左数组，在inorder不为0的情况下执行
    {
        vector<int> LeftArray;
        for (int i = 0; i < inorder.size(); i++)
        {
            if (inorder[i] != num)
                LeftArray.push_back(inorder[i]);
            else
                break;
        }
        return LeftArray;
    }

    vector<int> FindRightArray(int& num, vector<int>& inorder)   //根据中值找右数组，在inorder不为0的情况下执行
    {
        vector<int> RightArray;
        int index = 0;
        for (int i = 0; i < inorder.size(); i++)
        {
            if (inorder[i] == num)
            {
                index = i + 1;
                break;
            }
        }

        for (int i = index; i < inorder.size(); i++)
        {
            RightArray.push_back(inorder[i]);
        }

        return RightArray;
    }

    int FindMiddleNum(vector<int>& Array1, vector<int>& Array2)  //Array1为前序，Array2为从中序分出来的数组
    {
        for (int i = 0; i < Array1.size(); i++)
        {
            auto result = find(Array2.begin(), Array2.end(), Array1[i]); //查找Array2中是否有Array1中的值

            if (result != Array2.end()) //能找到
                return  Array1[i];      //找到第一个就返回
        }
        return -1;                      //找不到则返回-1
    }

};

int main()
{   
//    std::cout << "Hello World!\n";
    vector<int> preorder={ 1, 2, 4, 3, 5, 6 };
    vector<int> inorder = { 2, 4, 1, 3, 6, 5 };
    Solution MySolution;
    TreeNode * TNode = MySolution.buildTree(preorder, inorder);
    MySolution.SequenceTraversal(TNode);
    


}

leetcode官解：

在中序遍历中对根节点进行定位时，一种简单的方法是直接扫描整个中序遍历的结果并找出根节点，但这样做的时间复杂度较高。我们可以考虑使用哈希表来帮助我们快速地定位根节点。对于哈希映射中的每个键值对，键表示一个元素（节点的值），值表示其在中序遍历中的出现位置。在构造二叉树的过程之前，我们可以对中序遍历的列表进行一遍扫描，就可以构造出这个哈希映射。在此后构造二叉树的过程中，我们就只需要 O(1) 的时间对根节点进行定位了。

归纳总结了官解的思路：

class Solution {
private:
    unordered_map<int, int> index;

public:
    TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return nullptr;
        }
        
        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = index[preorder[preorder_root]];
        
        // 先把根节点建立出来
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        // 构造哈希映射，帮助我们快速定位根节点
        for (int i = 0; i < n; ++i) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/zhong-jian-er-cha-shu-lcof/solution/mian-shi-ti-07-zhong-jian-er-cha-shu-by-leetcode-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。