[Leetcode] 105, 106, 96

最新推荐文章于 2024-04-17 23:16:48 发布

鹿行见马

最新推荐文章于 2024-04-17 23:16:48 发布

阅读量248

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode刷题

本文链接：https://blog.youkuaiyun.com/coderqich/article/details/77415193

Leetcode刷题专栏收录该内容

34 篇文章

订阅专栏

本文介绍如何从不同的遍历序列构建二叉树的方法，包括先序与中序、中序与后序两种情况，并提供了一种递归解决方案。此外，还探讨了给定数字n时，构造不同结构的二叉搜索树的数量问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

105. Construct Binary Tree from Preorder and Inorder Traversal

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

Solution: 直接递归求解。

关于先序遍历、中序遍历详见：http://blog.youkuaiyun.com/prince_jun/article/details/7699024

Code:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return buildTree(preorder.begin(), inorder.begin(), inorder.size());
    }
private:
    TreeNode* buildTree(vector<int>::iterator prebegin, vector<int>::iterator inbegin, int size) {
        if(size<=0) return NULL;
        TreeNode* root = new TreeNode(*prebegin);
        vector<int>::iterator itroot = find(inbegin, inbegin+size, *prebegin);
        int sizeleft = itroot-inbegin;
        int sizeright = size - 1 - sizeleft; 
        TreeNode* left = buildTree(prebegin+1, inbegin, sizeleft);
        TreeNode* right = buildTree(prebegin+sizeleft+1, itroot+1, sizeright);
        root->left = left;
        root->right = right;
        return root;
    }
};

106. Construct Binary Tree from Inorder and Postorder Traversal

Given inorder and postorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

Solution: 递归。

Code:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return buildTree(inorder.begin(), postorder.end()-1, postorder.size());
    }
private:
    TreeNode* buildTree(vector<int>::iterator inbegin, vector<int>::iterator postend, int size){
        if(size==0) return NULL;
        vector<int>::iterator itroot = find(inbegin, inbegin+size, *postend);
        TreeNode* root = new TreeNode(*postend);
        
        int sizeleft = itroot - inbegin;
        int sizeright = size - 1 - sizeleft;
        TreeNode* left = buildTree(inbegin, postend-1-sizeright, sizeleft);
        TreeNode* right = buildTree(itroot+1, postend-1, sizeright);
        
        root->left = left;
        root->right = right;
        return root;
    }
};

96. Unique Binary Search Trees

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

For example,
Given n = 3, there are a total of 5 unique BST's.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

Solution:输入n时，可以分为根节点是1-n的n种子情况。对于根节点是x时，左子树是比x小的点，一共有x-1个不相等的数，其可能性的数量等于numTrees(x-1)；右子树是比x大的点，一共有n-x个点，其可能性等于numTrees(n-x)。

根据上面的分析可以得到递推公式：

根据这条递推公式就能解除答案，但要注意，递归会超时，这题只能用迭代来写。

Code:

class Solution {
public:
    int numTrees(int n) {
        vector<int> ans(n+1,0);
        ans[0] = 1;
        ans[1] = 1;
        int t = 1;
        while(t<n){
            t++;
            for(int i=1; i<=t; i++){
                ans[t] += ans[i-1]*ans[t-i];
            }
        }
        return ans[n];
    }
};