LeetCode 654.最大二叉树

2024-03-08 08:04
文章标签 leetcode 二叉树 最大 654

本文主要是介绍LeetCode 654.最大二叉树，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值 左边 的 子数组前缀上 构建左子树。
递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 nums 构建的 最大二叉树 。

示例 1：
在这里插入图片描述

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：

  • [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    • [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
      • 空数组，无子节点。
      • [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
        • 空数组，无子节点。
        • 只有一个元素，所以子节点是一个值为 1 的节点。
    • [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
      • 只有一个元素，所以子节点是一个值为 0 的节点。
      • 空数组，无子节点。
        示例 2：
        在这里插入图片描述

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

法一：递归构建：

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}* };*/
class Solution {
public:TreeNode* constructMaximumBinaryTree(vector<int>& nums) {return build(nums, 0, nums.size() - 1);}private:TreeNode *build(vector<int> &nums, int begin, int end){if (begin > end){return nullptr;}int max = -1;int maxIndex = -1;for (int i = begin; i <= end; ++i){if (nums[i] > max){max = nums[i];maxIndex = i;}}TreeNode *node = new TreeNode(max);node->left = build(nums, begin, maxIndex - 1);node->right = build(nums, maxIndex + 1, end);return node;}
};

如果nums的长度为n，此算法时间复杂度为O(n 2 ^2 2)，空间复杂度为O(1)。

法二：单调栈，单调栈用于在线性时间内寻找数组中每个元素左边第一个大（小）于该值的值，或右边第一个大（小）于该值的值。简单介绍一下单调栈，我们遍历nums中的每个元素，每遍历到一个元素，如果栈顶的元素小于当前遍历到的元素，就做出栈操作，直到栈顶元素值大于当前遍历到的元素，或栈为空，这些出栈元素右边第一个大于它们的值就是当前遍历到的元素，做完出栈操作后，栈顶元素就是当前元素的左边第一个大于当前元素的值，然后再把当前遍历到的元素入栈：

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}* };*/
class Solution {
public:TreeNode* constructMaximumBinaryTree(vector<int>& nums) {stack<int> s;vector<TreeNode *> nodeArr(nums.size(), nullptr);TreeNode *root = nullptr;for (int i = 0; i < nums.size(); ++i){nodeArr[i] = new TreeNode(nums[i]);while (!s.empty() && nums[s.top()] < nums[i]){nodeArr[i]->left = nodeArr[s.top()];s.pop();}if (!s.empty()){nodeArr[s.top()]->right = nodeArr[i];}s.push(i);if (s.size() == 1){root = nodeArr[i];}}return root;}
};

如果nums的长度为n，此算法时间复杂度为O(n)，空间复杂度为O(n)。

法三：线段树，线段树可以logn的效率查找某区间内的最大值，将其与法一中找区间最大值的部分替换，可将找极值的时间复杂度降为logn。线段树的核心在于把数组的每一段的最大值以树来存储，如找数组3、2、1、6、0、5的极值，我们递归地处理它，第一步将其分为两部分，分别为3、2、1和6、0、5，然后极值为这两部分极值中较大的那个，继续递归处理，直到只有单个元素，此时我们就可以知道当前区间的极值了，因为只有一个元素，极值就是它本身，然后递归向上返回，即可求得每一段的极值：

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}* };*/
class Solution {
public:TreeNode* constructMaximumBinaryTree(vector<int>& nums) {// 线段树需要开4倍内存nodeArr.resize(nums.size() * 4 , nullptr);buildSegmentTree(1, nums.size(), 1, nums);return buildAns(1, nums.size());}private:TreeNode *buildAns(int left, int right){if (left > right){return nullptr;}pair<int, int> max = search(left, right, 1);int maxIndex = max.first;int maxValue = max.second;TreeNode *node = new TreeNode(maxValue);node->left = buildAns(left, maxIndex - 1);node->right = buildAns(maxIndex + 1, right);return node;}class Node{public:Node(int left, int right, int maxValue, int maxIndex) : left(left), right(right), maxValue(maxValue),maxIndex(maxIndex){}int left;int right;int maxValue;int maxIndex;};vector<Node *> nodeArr;void buildSegmentTree(int left, int right, int x, vector<int> &nums){if (left > right){return;}// 如果是叶子结点if (left == right){nodeArr[x] = new Node(left, right, nums[left - 1], left);return;}int mid = left + (right - left) / 2;buildSegmentTree(left, mid, 2 * x, nums);buildSegmentTree(mid + 1, right, 2 * x + 1, nums);if (nodeArr[2 * x]->maxValue > nodeArr[2 * x + 1]->maxValue){nodeArr[x] = new Node(left, right, nodeArr[2 * x]->maxValue, nodeArr[2 * x]->maxIndex);}else{nodeArr[x] = new Node(left, right, nodeArr[2 * x + 1]->maxValue, nodeArr[2 * x + 1]->maxIndex);}}pair<int, int> search(int left, int right, int x){if (left == nodeArr[x]->left && right == nodeArr[x]->right){return {nodeArr[x]->maxIndex, nodeArr[x]->maxValue};}int mid = (nodeArr[x]->left + nodeArr[x]->right) / 2;// 如果要查找的范围在当前节点表示范围中点的左边（包括mid，因为建线段树时mid属于左边子树）// 说明要查找的范围在左子树上// 之所以与mid做对比，是因为子树的每个节点的范围就是按mid分的if (right <= mid){return search(left, right, 2 * x);}// 如果要查找的范围在当前节点表示范围中点的右边，说明要查找的范围在右子树上// 此处要用>而非>=，因为mid属于右子树，left只有完全属于右子树时，才只在右子树上查if (left > mid){return search(left, right, 2 * x + 1);}// 如果跨mid，就从两个子树中找pair<int, int> leftMax = search(left, mid, 2 * x);pair<int, int> rightMax = search(mid + 1, right, 2 * x + 1);if (leftMax.second > rightMax.second){return leftMax;}else{return rightMax;}}
};

如果nums的长度为n，此算法时间复杂度为O(nlogn)，空间复杂度为O(n)。

法四：ST表，类似法三，ST表能以O(1)的时间查找某一段的极值。ST表的建表用时为O(nlogn)，而线段树的建树用时为O(n)，但查询时，ST表比线段树快得多。线段树可以动态更改节点值，而ST表不支持，因此ST表更适用于值不会被修改的情况。简单介绍一下ST表，它是一个二维数组，a[i][j]表示从i开始的2的j次方个元素的极值是多少，在查询时，我们把查询区间分为有重叠部分的两段，然后取两段的极值做对比。为什么要取两段？因为二维数组里存的是从要查询的区间开始的、长为2的幂的区间的极值，我们查询的区间长度很有可能不是2的幂，因此需要分为两部分，这两部分一定会有重叠，这也隐含着ST表适用于那种有重叠部分也不影响结果的问题，如极值、求最大公约数等：

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}*     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}* };*/
class Solution {
public:TreeNode* constructMaximumBinaryTree(vector<int>& nums) {// 由于nums中元素个数最大为1000，因此2的10次方即可完全覆盖int exp = log(nums.size()) / log(2);vector<vector<pair<int, int>>> st(nums.size(), vector<pair<int, int>>(exp + 1, {-1, -1}));for (int i = 0; i < st.size(); ++i){// 初始化，从i开始，长为2的0次方（即1）的极值为它自己st[i][0] = {nums[i], i};}// j最大为9，我们只会用到2的9次方的值，因为查找时我们会把区间分为两段for (int j = 1; j < st[0].size(); ++j){// 循环条件部分保证了不会索引超出for (int i = 0; i + (1 << (j - 1)) < nums.size(); ++i){// st[i][j - 1]是2的j-1次方个数字，为第一段// st[i + (1 << (j - 1))][j - 1]也是2的j-1次方个数字，从第一段的后面一个位置开始// 注意st[i + (1 << (j - 1))][j - 1]中的i + (1 << (j - 1))部分是循环条件st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);}}return build(0, nums.size() - 1, nums, st);}private:TreeNode *build(int left, int right, vector<int> &nums, vector<vector<pair<int, int>>> &st){if (left > right){return nullptr;}// 以2为底，范围内数字个数的对数，将结果再去掉小数，这是最大的两段长度int num = log(right - left + 1) / log(2);// 两段会有交叉，如果left为0，right为5，则num为2// 此时会取从0开始的4个数字的极值和从1开始的4个数字的极值两者更大值const pair<int, int> &target = max(st[left][num], st[right - (1 << num) + 1][num]);int maxValue = target.first;int maxIndex = target.second;TreeNode *node = new TreeNode(maxValue);node->left = build(left, maxIndex - 1, nums, st);node->right = build(maxIndex + 1, right, nums, st);return node;}
};

此算法时间复杂度为O(nlogn)，用于建表；空间复杂度为O(nlogn)。

这篇关于LeetCode 654.最大二叉树的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/786510。

相关文章

如何提高Redis服务器的最大打开文件数限制

如何提高Redis服务器的最大打开文件数限制

《如何提高Redis服务器的最大打开文件数限制》文章讨论了如何提高Redis服务器的最大打开文件数限制,以支持高并发服务,本文给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录如何提高Redis服务器的最大打开文件数限制问题诊断解决步骤1. 修改系统级别的限制2. 为Redis进程特别设置限制
阅读更多...
哈希leetcode-1

哈希leetcode-1

目录 1前言 2.例题  2.1两数之和 2.2判断是否互为字符重排 2.3存在重复元素1 2.4存在重复元素2 2.5字母异位词分组 1前言 哈希表主要是适合于快速查找某个元素（O(1)） 当我们要频繁的查找某个元素，第一哈希表O(1)，第二，二分O(log n) 一般可以分为语言自带的容器哈希和用数组模拟的简易哈希。 最简单的比如数组模拟字符存储，只要开26个c
阅读更多...
poj 3723 kruscal，反边取最大生成树。

poj 3723 kruscal，反边取最大生成树。

题意： 需要征募女兵N人，男兵M人。 每征募一个人需要花费10000美元，但是如果已经招募的人中有一些关系亲密的人，那么可以少花一些钱。 给出若干的男女之间的1~9999之间的亲密关系度，征募某个人的费用是10000 - （已经征募的人中和自己的亲密度的最大值）。 要求通过适当的招募顺序使得征募所有人的费用最小。 解析： 先设想无向图，在征募某个人a时，如果使用了a和b之间的关系
阅读更多...
poj 3258 二分最小值最大

poj 3258 二分最小值最大

题意： 有一些石头排成一条线，第一个和最后一个不能去掉。 其余的共可以去掉m块，要使去掉后石头间距的最小值最大。 解析： 二分石头，最小值最大。 代码： #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <c
阅读更多...
poj 2175 最小费用最大流TLE

poj 2175 最小费用最大流TLE

题意： 一条街上有n个大楼，坐标为xi，yi，bi个人在里面工作。 然后防空洞的坐标为pj，qj，可以容纳cj个人。 从大楼i中的人到防空洞j去避难所需的时间为 abs（xi - pi） + （yi - qi） + 1。 现在设计了一个避难计划，指定从大楼i到防空洞j避难的人数 eij。 判断如果按照原计划进行，所有人避难所用的时间总和是不是最小的。 若是，输出“OPETIMAL",若
阅读更多...
poj 2135 有流量限制的最小费用最大流

poj 2135 有流量限制的最小费用最大流

题意： 农场里有n块地，其中约翰的家在1号地，二n号地有个很大的仓库。 农场有M条道路（双向），道路i连接着ai号地和bi号地，长度为ci。 约翰希望按照从家里出发，经过若干块地后到达仓库，然后再返回家中的顺序带朋友参观。 如果要求往返不能经过同一条路两次，求参观路线总长度的最小值。 解析： 如果只考虑去或者回的情况，问题只不过是无向图中两点之间的最短路问题。 但是现在要去要回
阅读更多...
poj 2594 二分图最大独立集

poj 2594 二分图最大独立集

题意： 求一张图的最大独立集，这题不同的地方在于，间接相邻的点也可以有一条边，所以用floyd来把间接相邻的边也连起来。 代码： #include <iostream>#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <cmath>#include <sta
阅读更多...
poj 3422 有流量限制的最小费用流 反用求最大 + 拆点

poj 3422 有流量限制的最小费用流 反用求最大 + 拆点

题意： 给一个n*n（50 * 50） 的数字迷宫，从左上点开始走，走到右下点。 每次只能往右移一格，或者往下移一格。 每个格子，第一次到达时可以获得格子对应的数字作为奖励，再次到达则没有奖励。 问走k次这个迷宫，最大能获得多少奖励。 解析： 拆点，拿样例来说明： 3 2 1 2 3 0 2 1 1 4 2 3*3的数字迷宫，走两次最大能获得多少奖励。 将每个点拆成两个
阅读更多...
poj 3692 二分图最大独立集

poj 3692 二分图最大独立集

题意： 幼儿园里，有G个女生和B个男生。 他们中间有女生和女生认识，男生男生认识，也有男生和女生认识的。 现在要选出一些人，使得这里面的人都认识，问最多能选多少人。 解析： 反过来建边，将不认识的男生和女生相连，然后求一个二分图的最大独立集就行了。 下图很直观： 点击打开链接 原图： 现图： 、 代码： #pragma comment(
阅读更多...
最大流、 最小费用最大流终极版模板

最大流、 最小费用最大流终极版模板

最大流  const int inf = 1000000000 ;const int maxn = 20000 , maxm = 500000 ;struct Edge{int v , f ,next ;Edge(){}Edge(int _v , int _f , int _next):v(_v) ,f(_f),next(_next){}};int sourse , mee
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2