《程序员面试金典（第6版）》面试题 04.09. 二叉搜索树序列

题目描述

从左向右遍历一个数组，通过不断将其中的元素插入树中可以逐步地生成一棵二叉搜索树。

给定一个由不同节点组成的二叉搜索树 root，输出所有可能生成此树的数组。

示例 1:

输入: root = [2,1,3]
输出: [[2,1,3],[2,3,1]]
解释: 数组 [2,1,3]、[2,3,1] 均可以通过从左向右遍历元素插入树中形成以下二叉搜索树

   2 
  / \ 
 1   3

示例 2:

• 输入: root = [4,1,null,null,3,2]
  输出: [[4,1,3,2]]

提示：

• 二叉搜索树中的节点数在 [0, 1000] 的范围内
  1 <= 节点值 <= 10^6
  用例保证符合要求的数组数量不超过 5000

解题思路与代码

这道题是一道hard难度的题。我觉得这道题最难的地方，归纳题意。阅读理解是最难的地方。一上来就看到[[2,1,3],[2,3,1]] ，谁不迷糊啊，这是啥呀。我第一开始以为，就是我们一个二叉树，我可以选择先排列它的左子节点，或者右子节点。但后来发现，并不是这样。我先是随便给了写了一个能通过的题解，通过测试案例，发现实际是这样的：

通过读题，精炼出如下信息：任何一个节点，要排列在它的子孙节点前。是的整段题目描述，就总结出这么一句话。因为我们要把所有符合这句话的所有可能都添加进一个结果集中然后去返回。

想到这里，其实就简单多了，也就明了多了，其实也就是一个变相的排列问题。我们用回溯法就可以解决。

回溯法（使用双端队列解决）

首先我们肯定得准备两个东西，一个用来存储所有结果，一个呢用来单次结果。分别是result，path。

起床，我们用双端队列deque来作为回溯遍历的主体。为什么不用queue呢，是因为用queue的时间会超出限制。

现在来简单讲解一下代码实现。

我们先将root压入deque。回溯前先确定deque的大小。这其实和递归二叉树的层次遍历有点像。这个size其实就是我们回溯的次数-1。

用for循环，边层次遍历，边去进行回溯。每次我们先记录队列的头元素，把它添加入path中，然后将队列头的元素压出队列，再将队列的子节点压入队列。
然后开始回溯。
之后，我们将前面压入的队列的弹出，弹出队列的再压入队列。path也是如此，将添加进数组的元素再删除出去。就和呼吸一样，只不过是先吸入，再呼出罢了。

其实你感觉这个回溯法，真的和二叉树的层序遍历有点像，但区别就是，它将每一层之间的元素，所有的顺序都记录下来，作为结果集合的一种，最后添加进结果集中。

我感觉，这已经是我能给大家把这个回溯法揉碎了，再讲出来的极限了。如果实在搞不清楚，就先看代码吧。

具体的代码实现如下：

/**
 * 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:
    vector<vector<int>> result;
    vector<int> path;
    vector<vector<int>> BSTSequences(TreeNode* root) {
        if(root ==nullptr) return {{}};
        deque<TreeNode*> que;
        que.push_back(root);
        backTracking(que);
        return result;
    }

    void backTracking(deque<TreeNode*>& que){
        if(que.empty()){
            result.push_back(path);
            return;
        }

        int size = que.size(); //回溯size - 1 次。

        for(int i = 0; i < size; ++i){
            TreeNode* cur = que.front();

            que.pop_front();
            path.push_back(cur->val); //把节点数值加入路径中
            if(cur->left) que.push_back(cur->left);
            if(cur->right) que.push_back(cur->right);

            backTracking(que); //开始回溯；

            if(cur->left) que.pop_back();
            if(cur->right) que.pop_back();
            path.pop_back(); //回溯开始前，我们将节点加入了路径，那么回溯后，自然也要请出路径
            que.push_back(cur); //回溯开始前，我们将节点推出了队列，那么回溯完成就要再添加回队列。
        }
        return;
    }
};

复杂度分析

时间复杂度：

• 该算法的时间复杂度为O(N!),其中N表示二叉树的节点个数。虽然算法使用deque和回溯方法优化了递归算法的时间和空间复杂度。但是由于问题本身的特殊性质（即队列中每个元素都需要被检查），使得总体的时间复杂度无法避免阶乘级别。
• 具体地说，在最坏情况下（即完全二叉树的情况下)，如果节点数为 N，则回溯次数会达到 (N-1)! 次，而每次回溯需要花费 O(N) 的时间进行操作，因此最终时间复杂度为 O(N * (N-1)! )，与直接暴力求解时的时间复杂度相同。

空间复杂度：

• 用于存储结果（即vector result），需要O(N!)的空间。
• 用于辅助计算过程的空间；队列deque<TreeNode*> que、路径path等所消耗的空间，需要 O(N) 的单元格空间。
• 因此，算法的总体空间复杂度为O(N * N!)

总结

这道题是一道十足的困难题。如果你对回溯算法一点都没有了解了话，真的就感觉和看天书也没差了。回溯算法和递归算法很像，但其中又有点细微的差别，回溯是有一个回的过称，也有一个溯的过称。就像你扔出去一块回旋镖，最后回旋镖还会回到你的手上。那这就是回溯。

总之，多做题，多看看。会的就多，也就没那么难了。