剑指offer 第20天分治算法（中等）C++题解

最新推荐文章于 2024-09-13 15:56:13 发布

杨小木木

最新推荐文章于 2024-09-13 15:56:13 发布

阅读量267

点赞数

分类专栏：剑指offer 文章标签：算法 c++ leetcode 数据结构

本文链接：https://blog.csdn.net/qq_39858171/article/details/127861001

版权

剑指offer 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

一、重建二叉树

剑指 Offer 07. 重建二叉树https://leetcode.cn/problems/zhong-jian-er-cha-shu-lcof/

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

限制：

0 <= 节点个数 <= 5000

注意：本题与主站 105 题重复：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

解题思路：

代码随想录代码随想录PDF，代码随想录百度网盘，代码随想录知识星球，代码随想录八股文PDF，代码随想录刷题路线，代码随想录知识星球八股文https://www.programmercarl.com/0106.%E4%BB%8E%E4%B8%AD%E5%BA%8F%E4%B8%8E%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86%E5%BA%8F%E5%88%97%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E6%80%9D%E8%B7%AF

具体细节：

坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树https://www.bilibili.com/video/BV1vW4y1i7dn 复杂度分析：

1.时间复杂度：最差情况下递归遍历N个节点，每次递归找到节点在数组中位置需遍历整个数组，故需O（N^2）时间复杂度。

2.空间复杂度：最差情况下递归深度为N，需O（N）的栈空间。

代码实现：

class Solution {
private:
        TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
        if (preorderBegin == preorderEnd) return NULL;

        int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
        TreeNode* root = new TreeNode(rootValue);

        if (preorderEnd - preorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割前序数组
        // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
        int leftPreorderBegin =  preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 终止位置是起始位置加上中序左区间的大小size
        // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
        int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  preorder, leftPreorderBegin, leftPreorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (inorder.size() == 0 || preorder.size() == 0) return NULL;

        // 参数坚持左闭右开的原则
        return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
    }
};

二、数值的整数次方

剑指 Offer 16. 数值的整数次方https://leetcode.cn/problems/shu-zhi-de-zheng-shu-ci-fang-lcof/

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^n）。不得使用库函数，同时不需要考虑大数问题。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2^-2 = 1/2^2 = 1/4 = 0.25

提示：

-100.0 < x < 100.0
-2^31 <= n <= 2^31-1
-10^4 <= x^n <= 10^4

注意：本题与主站 50 题相同：https://leetcode-cn.com/problems/powx-n/

解题思路：

1.可以想到最简单方法将结果累乘起来，需要O（N）的时间复杂度。

2.更优方法是快速幂法，可以将时间复杂度降低至O（log2N）。 $x^n = x^{n/2} \times x^{n/2} = (x^2)^{n/2}$ ，令 n/2 为整数，则需要分为奇偶两种情况（设向下取整除法符号为 "//" ）：

当 n 为偶数： $x^n = (x^2)^{n//2}$ ；

当 n 为奇数： $x^n = x(x^2)^{n//2}$ ，即会多出一项 x ；

循环计算可将时间复杂度将为O（log2N）。

3.向下整除 n // 2 等价于 右移一位 n >> 1 ；取余数 n % 2 等价于 判断二进制最右一位值 n & 1 。

具体细节：

1.当 x = 0 时：直接返回 0 （避免后续 x = 1 / x 操作报错）。

2.初始化 res = 1 ；

3.当 n < 0 时：把问题转化至 n ≥ 0 的范围内，即执行 x = 1/x ，n = - n；

4.循环计算：当 n = 0 时跳出；

（1）当 n & 1 = 1 时：将当前 x 乘入 res （即 res *= x ）；

（2）执行 x = x^2（即 x *= x ）；

（3）执行 n 右移一位（即 n >>= 1）。

5.返回 res 。

复杂度分析：

1.时间复杂度：O（log2N）。

2.空间复杂度：O（1）。

代码实现：

class Solution {
public:
    double myPow(double x, int n) {
        if (n == 0) return 1;
        if (n == -1) return 1 / x;
        if (n & 1) return myPow(x * x, n >> 1) * x;
        else return myPow(x * x, n >> 1);
    }
};

三、二叉搜索树的后序遍历序列

剑指 Offer 33. 二叉搜索树的后序遍历序列https://leetcode.cn/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。

参考以下这颗二叉搜索树：

5
/ \
2 6
/ \
1 3

示例 1：

输入: [1,6,3,2,5]
输出: false

示例 2：

输入: [1,3,2,6,5]
输出: true

提示：

数组长度 <= 1000

解题思路：

1.根据后序遍历和二叉搜索树的定义，可以通过递归判断所有子树的正确性，即后序遍历是否满足二叉搜索树的定义。

2.遍历数组找到大于当前节点值的第一个节点，记为根节点，判断后续节点的值是否大于此根节点，若都大于则当前节点符合条件，递归判断左右子树，若不都大于则不符合条件。

具体细节：

1.递归终止条件当左区间大于等于右区（left >= right）间时返回true。

2.遍历区间内元素，记数组right的节点为根节点，找到大于根节点值的第一个记为mid。则左子树的区间为[left,mid]，判断mid到右区间的节点是否都大于根节点的值。

3.如果都大于则说明此树满足条件，递归判断左右子树的区间。左子树区间为[left,mid],右子树区间为[mid,right - 1]。

4.如果不大于则返回false。

复杂度分析：

1.时间复杂度：最差情况下需遍历树的整个节点，每个节点都遍历数组，故需O（N^2）的时间复杂度。

2.空间复杂度：最差情况下递归深度为N，需占用O（N）的栈空间。

代码实现：

class Solution {
public:
    bool verifyPostorder(vector<int>& postorder) {
        if (postorder.size() == 0 || postorder.size() == 1) return true;
        return verifySubPostorder(postorder, 0, postorder.size() - 1);
    }
    bool verifySubPostorder(vector<int>& postorder, int left, int right) {
        if (left >= right) return true;
        int index = left;
        while (postorder[index] < postorder[right]) index++;
        int mid = index;
        while (postorder[index] > postorder[right]) index++;
        return index == right && verifySubPostorder(postorder, left, mid - 1) && verifySubPostorder(postorder, mid, right - 1);
    }
};