654.最大二叉树

力扣题目地址

// 递归初版
    TreeNode* constructMaximumBinaryTree1(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        // 数组size为1时，叶子节点，构造节点
        if (nums.size() == 1) {
            node->val = nums[0];
            return node;
        }
        // 找到数组中最大的值和对应的下标
        int maxVal = 0;
        int maxValIndex = 0;
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
                maxValIndex = i;
            }
        }
        // 用最大值构造根节点
        node->val = maxVal;
        // 构造左子树
        // 保证左区间大于0
        if (maxValIndex > 0) {
            vector<int> left(nums.begin(), nums.begin() + maxValIndex);
            node->left = constructMaximumBinaryTree1(left);
        }
        // 构造右子树
        // 保证右区间大于0
        if (maxValIndex < (nums.size() - 1)) {
            vector<int> right(nums.begin() + maxValIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree1(right);
        }
        return node;
    }

    // 递归优化版 数组下标

    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right) {
            return nullptr;
        }

        // 分割点下标：maxValIndex
        int maxValIndex = left;
        for (int i = left; i < right; ++i) {
            if (nums[i] > nums[maxValIndex]) {
                maxValIndex = i;
            }
        }
        TreeNode* root = new TreeNode(nums[maxValIndex]);
        // 左闭右开的 左区间
        root->left = traversal(nums, left, maxValIndex);
        // 左闭右开的 右区间
        root->right = traversal(nums, maxValIndex + 1, right);
        return root;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }

617.合并二叉树

力扣题目链接

// 递归法+ 前序遍历
    TreeNode* mergeTrees1(TreeNode* root1, TreeNode* root2) {
        // 终止条件
        if (root1 == NULL) {
            return root2;
        }
        if (root2 == NULL) {
            return root1;
        }
        // 单层递归的逻辑
        root1->val += root2->val;
        // 递归
        root1->left = mergeTrees1(root1->left, root2->left);
        root1->right = mergeTrees1(root1->right, root2->right);
        return root1;
    }

    // 迭代法
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == NULL) {
            return root2;
        }
        if (root2 == NULL) {
            return root1;
        }
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);
        while (!que.empty()) {
            // 取出两棵树的对应节点
            TreeNode* node1 = que.front();
            que.pop();
            TreeNode* node2 = que.front();
            que.pop();
            // 此时两棵树的对应节点必定不为空
            node1->val += node2->val;
            // 两对应节点的左子树均不为空的时候
            if (node1->left != NULL && node2->left != NULL) {
                que.push(node1->left);
                que.push(node2->left);
            }
            // 两对应节点的右子树均不为空的时候
            if (node1->right != NULL && node2->right != NULL) {
                que.push(node1->right);
                que.push(node2->right);
            }
            // node1的左子树为空，node2不为空
            if (node1->left == NULL && node2->left != NULL) {
                node1->left = node2->left;
            }
            // node1的右子树为空，node2不为空
            if (node1->right == NULL && node2->right != NULL) {
                node1->right = node2->right;
            }
            // 其他情况不变动

        }
        return root1;
    }

700.二叉搜索树中的搜索

力扣题目地址

// 递归法
    TreeNode* searchBST(TreeNode* root, int val) {
        if (root == NULL || root->val == val) {
            return root;
        }
        TreeNode* res = NULL;
        if (root->val > val) {
            res = searchBST(root->left, val);
        }
        if (root->val < val) {
            res = searchBST(root->right, val);
        }
        return res;
    }
    // 迭代法
    TreeNode* searchBST1(TreeNode* root, int val) {
        while (root != NULL) {
            if (root->val > val) {
                root = root->left;
            }
            else if (root->val < val) {
                root = root->right;
            }
            else {
                return root;
            }
        }
        return NULL;
    }

98.验证二叉搜索树

力扣题目链接

vector<int> vec;
    // 中序遍历二叉搜索树——>单调递增数列
    // 递归法
    void inorder(TreeNode* node) {
        if (node == NULL) {
            return;
        }
        inorder(node->left);
        vec.push_back(node->val);
        inorder(node->right);
    }
    bool isValidBST(TreeNode* root) {
        inorder(root);
        for (int i = 1; i < vec.size(); ++i) {
            if (vec[i] <= vec[i - 1]) {
                return false;
            }
        }
        return true;
    }

    // 迭代法
    bool isValidBST1(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                if (pre != NULL && cur->val <= pre->val) {
                    return false;
                }
                pre = cur ;
                cur = cur->right;
            }
        }
        return true;
    }