首页 > 其他分享> > 每日刷题 Day14

每日刷题 Day14

2022-01-24 23:58:56 作者：互联网

题一：二叉树展开为链表
给你二叉树的根结点 root ，请你将它展开为一个单链表：
展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树先序遍历顺序相同。

示例 1：
输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [0]
输出：[0]

提示：
树中结点数在范围 [0, 2000] 内
-100 <= Node.val <= 100

进阶：你可以使用原地算法（O(1) 额外空间）展开这棵树吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list

/**
 * 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:
    void flatten(TreeNode* root) {
        //思路：先将结点的左子树和右子树展开为链表，最后再将两个合并起来
        if(root==NULL)
            return;
        //先将左子树展开
        flatten(root->left);
        //再将右子树展开
        flatten(root->right);
        //此时，左右子树已经展开成一条链表了
        
        TreeNode *left=root->left;
        TreeNode *right=root->right;
        //将左子树链接到结点的right指针上 
        root->left=NULL;
        root->right=left;
        //将右子数连到树的末端
        TreeNode *p=root;
        while(p!=NULL&&p->right!=NULL){
            p=p->right;
        }
        p->right=right;
    }
};

题二：最大二叉树
给定一个不含重复元素的整数数组 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 中的所有整数互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-binary-tree

/**
 * 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* build(vector<int>& nums,int begin,int end){
        if(begin>end)
            return nullptr;    //nullptr是空指针
        int max=0;
        int index=begin;
        for(int i=begin;i<=end;i++){
            if(nums[i]>max){
                max=nums[i];
                index=i;
            }
        }
        TreeNode* root=new TreeNode(max);
        root->left=build(nums,begin,index-1);
        root->right=build(nums,index+1,end);
        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return build(nums,0,nums.size()-1);
    }
};

题三：从前序与中序遍历序列构造二叉树
给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

示例 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]

提示:
1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均无重复元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal

/**
 * 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* build(vector<int>& inorder,int inbegin,int inend, vector<int>& preorder,int postbegin,int postend){
        if(inbegin>inend||postbegin>postend)
            return nullptr;
        
        int Val=preorder[postbegin];  //这位根节点的值
        int index=0;
        for(int i=inbegin;i<=inend;i++){
            if(inorder[i]==Val){
                index=i;
                break;
            }
        }
        
        int leftSize = index - inbegin;
        TreeNode *root = new TreeNode(Val);
        // 递归构造左右子树
        root->left = build(inorder, inbegin, index - 1,
                            preorder, postbegin+1, postbegin+leftSize);
        root->right = build(inorder, index + 1, inend,
                            preorder, postbegin + leftSize+1, postend);
        return root;
    }
   
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return build(inorder,0,inorder.size()-1,preorder,0,preorder.size()-1);
    }
};

标签：right,TreeNode,int,inorder,每日,Day14,刷题,root,left
来源： https://blog.csdn.net/qq_47623568/article/details/122670125