二叉树的前序遍历，中序遍历，后序遍历，构造二叉树，对称二叉树

---

Title: “二叉树”
Date: 2021-03-16T20:26:11+08:00
author: LGJ_TT

1.二叉树的遍历：

1.1 前序遍历(访问顺序：root , root->left , root->right)

题目(力扣144)：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

class Solution {
public:
    void preorder(TreeNode* root,vector<int>& nums){
        //模板...
        if(root!=nullptr){
        nums.push_back(root->val);
        preorder(root->left,nums);
        preorder(root->right,nums);
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
       auto nums=vector<int>();
       preorder(root,nums);
       return nums;
    }
};

1.2 中序遍历（访问顺序：root->left , root , root->right)

只需将前序遍历中的模板改为：

if(root!=nullptr){
    inorder(root->left,nums);
    nums.push_back(root->val);
    inorder(root->right,nums);
}

1.3 后序遍历 （访问顺序：root->left , root->right , root)

同样的只需要将前序遍历中的模板改为：

if(root!=nullptr){
    postorder(root->left,nums);
    postorder(root->right,nums);
    nums.push_back(root->val);
}

2.二叉树的层次遍历

题目（力扣107): 给定一个二叉树，返回其节点值自底向上的层序遍历(即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历)。

解析：树的层次遍历可以使用广度优先搜索实现。从根节点开始搜索，每次遍历同一层的全部节点，使用一个列表存储该层的节点值。

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        auto levelOrder = vector<vector<int>>();
        if (!root) {
            return levelOrder;
        }
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            auto level=vector<int>();
            int size=q.size();
            for(int i=0;i<size;i++){
                auto node=q.front();
                q.pop();
                level.push_back(node->val);
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            levelOrder.push_back(level);
        }
        reverse(levelOrder.begin(),levelOrder.end());//反转，自底向上
        return levelOrder;
    }
};

3.从前序和中序遍历序列构造二叉树

题目(力扣105): 根据一棵树的前序遍历与中序遍历构造二叉树。（假设树中没有重复元素）

解析：

对于任意一颗树而言，前序遍历的形式总是

[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]；

而中序遍历的形式总是

[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]。

因此，我们在中序遍历中定位到根节点，那么我们就可以分别知道左子树和右子树中的节点数目。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有左右括号进行定位。

特别注意：使用哈希映射（HashMap）来帮助我们快速地定位根节点。

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 preleft=preorder_left;
        int pindex=index[preorder[preleft]];
        int x=preleft+1+pindex-1-inorder_left;
        TreeNode* root=new TreeNode(preorder[preleft]);
        root->left=myBuildTree(preorder,inorder,preleft+1,x,inorder_left,pindex-1);
        root->right=myBuildTree(preorder,inorder,x+1,preorder_right,pindex+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);
    }
};

4.对称的二叉树

题目(箭指offer28): 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

解析：

对称二叉树定义： 对于树中 任意两个对称节点 LL和 R，一定有：
L.val = R.val：即此两对称节点值相等。
L.left.val = R.right.val ：即 L的 左子节点 和 R 的 右子节点 对称；
L.right.val = R.left.val：即 L的 右子节点 和 R 的 左子节点 对称。

class Solution {
public:
    bool isSymmetric2(TreeNode* root1,TreeNode* root2){
        if(root1 == nullptr && root2 == nullptr) return true;
        if(root1 == nullptr || root2== nullptr ||root1->val !=root2->val) return false;
       return isSymmetric2(root1->left,root2->right)&&isSymmetric2(root1->right,root2->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
        return true;
        return isSymmetric2(root->left,root->right);
    }
};

5.二叉树中所有距离为K的结点

题目(力扣863)：给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。

返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。

解析：首先使用 DFS 遍历二叉树，为每个节点保存其父结点；使用 BFS 向三个方向搜索（左孩子、右孩子、父结点），当搜索第 K 次时，队列中的全部结点即为所求；

class Solution {
private:
    unordered_map<TreeNode*, TreeNode*> parent;
public:
    vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
        findParent(root,NULL,parent);
        queue<TreeNode*> q;
        q.push(target);
        unordered_set<TreeNode*> visited;
        visited.insert(target);//标记已经找过的
        vector<int> vec{};
        int distance=0;
        while(!q.empty()){
            int size=q.size();
            while(size--){
                TreeNode* node=q.front();
                q.pop();
             if(distance==K)
                   vec.push_back(node->val);
             if(node->left&&visited.find(node->left)==visited.end()){
                    q.push(node->left);
                    visited.insert(node->left);
                }
           if(node->right&&visited.find(node->right)==visited.end()){
                    q.push(node->right);
                    visited.insert(node->right);
                }
                TreeNode* par=parent[node];
                if(par!=NULL&&visited.find(par)==visited.end()){
                    q.push(par);
                    visited.insert(par);
                }
                  
            }
            ++distance;
            if(!vec.empty())
               break;

        }
        return vec;
        
    }
    void findParent(TreeNode* node,TreeNode* par,  unordered_map<TreeNode*, TreeNode*>& parent){
        if(node!=NULL){
            parent[node]=par;
            findParent(node->left,node,parent);
            findParent(node->right,node,parent);
        }
    }
};

备注： 由于创作时间急促，笔者能力有限，出错在所难免，若读者发现错误，敬请私信，万分感谢！