LeetCode/树操作综合

树一般使用递归方式来拆分成子问题

1. 合并二叉树

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1&&!root2) return nullptr;
        if(root1&&root2) 
        {root1->val+=root2->val;
        root1->left=mergeTrees(root1->left,root2->left);
        root1->right=mergeTrees(root1->right,root2->right);
    }
        else if(root2) return root2;
        return root1;
    }
};

2. 二叉树的直径（后序遍历）

class Solution {
public:
    int maxval=0;
    int diameterOfBinaryTree(TreeNode* root) {
        traceback(root);
        return maxval;
    }
    int traceback(TreeNode* root){
        if(!root) return 0;
        int left = traceback(root->left);
        int right =  traceback(root->right);
        int diameter = left+right;
        if(diameter>maxval) maxval = diameter;
        return max(left,right)+1;
    }
};

3. 层次遍历

4. 二叉树展开为链表

class Solution {
    public:
    void flatten(TreeNode *root) {
        if (!root) return;
        flatten(root->left);//左子树展成顺序链式
        TreeNode *right = root->right;//暂存右子树
        root->right = root->left;//将链式左子树给右节点
        root->left = NULL;//左节点赋NULL
        while (root->right != NULL) 
            root = root->right; //移到链式右子树末端
        flatten(right);//将原来右子树展开
        root->right = right;//拼接到新右子树末端
    }
};

5. 判断平衡二叉树（后序遍历）

class Solution {
public:
    int height(TreeNode* root) {
        if (root == NULL) return 0;//高度为0
        int leftHeight = height(root->left);//递归左节点并得到其高度
        if(leftHeight==-1) return -1;//用于打断右节点的递归
        int rightHeight = height(root->right);//递归右节点并得到其高度
        //不满足高度条件，传递回一个-1标志，同时打断在获得标志的情况打断运算和递归
        if (leftHeight==-1||rightHeight==-1||abs(leftHeight-rightHeight)>1)  return -1;
        else  return max(leftHeight, rightHeight) + 1;
    }
    bool isBalanced(TreeNode* root) {
        return height(root) >= 0;
    }
};

6. 判断二叉排序树（中序遍历）

//递归实现
class Solution {
public:
    long pre = LONG_MIN;
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        bool left = isValidBST(root->left);
        if(pre>=root->val||!left) return false;
        pre = root->val;
        bool right = isValidBST(root->right);
        return left&right;
    }
};

//栈实现
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stack;
        long long inorder = (long long)INT_MIN - 1;

        while (!stack.empty() || root != nullptr) {
            while (root != nullptr) {
                stack.push(root);
                root = root -> left;
            }
            root = stack.top();
            stack.pop();
            // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root -> val <= inorder) {
                return false;
            }
            inorder = root -> val;
            root = root -> right;
        }
        return true;
    }
};

7. 删除二叉搜索树中的节点

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) 
    {
        //深度优先遍历树，找对应节点，递归重构树
        if (!root)   return NULL;
        if (key > root->val)    root->right = deleteNode(root->right, key);     // 递归右子树
        else if (key < root->val)    root->left = deleteNode(root->left, key);  //递归左子树
        else    //找到要删除节点
        {
            if (! root->left)   return root->right; // 情况1，欲删除节点无左子
            if (! root->right)  return root->left;  // 情况2，欲删除节点无右子
            TreeNode* node = root->right;           // 情况3，欲删除节点左右子都有 
            while (node->left)          // 寻找欲删除节点右子树的最左节点
                node = node->left;
            node->left = root->left;    // 将欲删除节点的左子树成为其右子树的最左节点的左子树
            root = root->right;         // 欲删除节点的右子顶替其位置，节点被删除
        }
        return root;//没有找到 
    }
};

8. 二叉树剪枝

返回移除了所有不包含 1 的子树的原二叉树

class Solution {
public:
    //信息要往上传递
    TreeNode* pruneTree(TreeNode* root) {
        TreeNode* pre = new TreeNode();
        pre ->right = root;
        dfs(pre);
        return pre->right;
    }
    bool dfs(TreeNode* root){
        if(!root) return false;
        bool left = dfs(root->left);
        bool right = dfs(root->right);
        if(left==0) root->left = nullptr;
        if(right==0) root->right = nullptr;
        return left|right|root->val;
    }
};