leetcode—5/31

1.二叉树的中序遍历

给定一个二叉树，返回它的中序遍历

思路：递归

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
    void inorder(TreeNode* root, vector<int>& res)
    {
        if(root == nullptr)
        {
            return;
        }
        inorder(root -> left, res);
        res.push_back(root -> val);
        inorder(root -> right, res);
    }

非递归：用栈来做

1. 从跟节点一直往左走，将经过的所有节点压栈
2. 栈不空则出栈，将出栈节点添加到结果中并转向该节点的右子树
3. 栈空则重复执行上述步骤

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode* cur = root;
        while(cur != nullptr || !s.empty())
        {
            while(cur != nullptr)
            {
                s.push(cur);
                cur = cur -> left;
            }
            if(!s.empty())
            {
                cur = s.top();
                s.pop();
                res.push_back(cur -> val);
                cur = cur -> right;
            }
        }
        
        return res;
    }

2.不同的二叉搜索树II

给定一个整数n，生成所有由1…n为节点所组成的二叉搜索树

思路：

1. 二叉树一共有多少种？

• 假设给定n = 1，结果只有一种
• 当n > 1时，根为i(2 ≤ i ≤ n)的情况，定义函数f(n)，返回以n为输入的二叉树的个数。左边二叉树的数目是f(i - 1)，右边二叉树的个数是f(n - i)，共有f(i - 1) * f(n - i)情况

2. 以不同的数作为root，分别在i左边和右边构成二叉树，并排列组合，这便是递归过程

vector<TreeNode*> generateTrees(int n) {
        if(n == 0)
        {
            return {};
        }
        return generate(1, n);
    }
    
    vector<TreeNode*> generate(int left, int right)
    {
        if(left > right)
        {
            return {nullptr};
        }
        vector<TreeNode*> res;
        for(int i = left; i <= right; i++)
        {
            vector<TreeNode*> left_nodes = generate(left, i - 1);
            vector<TreeNode*> right_nodes = generate(i+ 1, right);
            for(int j = 0; j < left_nodes.size(); j++)
            {
                for(int k = 0; k < right_nodes.size(); k++)
                {
                    TreeNode* root = new TreeNode(i);
                    root -> left = left_nodes[j];
                    root -> right = right_nodes[k];
                    res.push_back(root);
                }
            }
        }
        return res;
    }