leetcode—树(easy) 3/8

1.N叉树的前序遍历

给定一个N叉树，返回其节点值的前序遍历。

2.N叉树的后序遍历

给定一个N叉树，返回其节点值的后序遍历。

3.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点和一个值。你需要在BST中找到节点值等于给定值的节点。返回以该节点为根的子树。如果节点不存在 ，则返回NULL。

4.叶子相似的树

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个叶值序列。如果有两棵二叉树的叶值序列是相同的，那么我们就认为他们是叶相似的。如果给定的两棵树是叶相似的，则返回true，否则返回false。

思路：遍历然后比较

5.递增顺序查找树

给定一个树，按中序遍历重新排列树，使树中最左边的节点现在是树的根，并且每个节点没有左子节点，只有一个右子节点。

思路 ：中序遍历构建一棵树，把每次遍历到的节点都加到上一次遍历的右子树上。

void mid_order(TreeNode* root, TreeNode* &parentHead)
    {
        if(root == nullptr)
        {
            return;
        }
        if(root -> left != nullptr)
        {
            mid_order(root -> left, parentHead);
        }
        if(root != nullptr)
        {
            TreeNode* node = new TreeNode(root -> val);
            parentHead -> right = node;
            parentHead = parentHead -> right;
        }
        if(root -> right != nullptr)
        {
            mid_order(root -> right, parentHead);
        }
    }
    TreeNode* increasingBST(TreeNode* root) {
        TreeNode* preHead = new TreeNode(-1);
        TreeNode* parentHead = preHead;
        mid_order(root, parentHead);
        return preHead -> right;
    }

6.单值二叉树

如果二叉树每个节点都具有相同的值，那么该二叉树就是 单值二叉树。只有给定的树是单指二叉树，才返回true，否则返回 false。

bool isUnivalTree(TreeNode* root) {
        if(root == nullptr)
        {
            return true;
        }
        if(root -> left == nullptr && root -> right == nullptr)
        {
            return true;
        }
        
        if(root -> left != nullptr && root -> val != root -> left -> val)
        {
            return false;
        }
        
        if(root -> right != nullptr && root -> val != root -> right -> val)
        {
            return false;
        }
        
        return isUnivalTree(root -> left) && isUnivalTree(root -> right);
    }

7.二叉树的堂兄弟节点

在二叉树中，根节点位于深度0处，每个深度为k的节点的子节点位于深度k+1处。如果二叉树的两个节点深度相同，但父节点不同，则他们是一对堂兄弟节点。判断两个值对应的节点是否是堂兄弟节点。

思路：用两个hash_map分别记录父节点以及其的深度

class Solution {
private:
    unordered_map<int, int> depth;
    unordered_map<int, TreeNode*> parent;
public:
    void dfs(TreeNode* root, TreeNode* pre)
    {
        if(root == nullptr)
        {
            return;
        }
        depth[root -> val] = pre != nullptr ? 1 + depth[pre -> val] : 0;
        parent[root -> val] = pre;
        dfs(root -> left, root);
        dfs(root -> right, root);
    }
    bool isCousins(TreeNode* root, int x, int y) {
        dfs(root, nullptr);
        return (depth[x] == depth[y] && parent[x] != parent[y]);
    }
};