如何在javascript中获得两个值或节点之间的差异

我正在努力解决这个问题。我没有得到预期的输出

给定具有根节点根的二叉搜索树（BST），返回树中任意两个不同节点的值之间的最小差值

例如：

输入：

root = [4,2,6,1,3,null,null]

1

输出：

root = [4,2,6,1,3,null,null]

1

说明：

请注意，root是一个TreeNode对象，而不是数组

给定的树[4,2,6,1,3，null，null]由下图表示：

      4
    /   \
  2      6
 / \    
1   3  

虽然此树中的最小差异为1，但它发生在节点1和节点2之间，也发生在节点3和节点2之间

我试过这样做

var minDiffInBST = function (root) {
    let min = Number.MAX_VALUE
    const getMin = (node) => {
        if (node.left && node.right) {
            console.log('both')
            return Math.min(node.val - node.left.val, node.right.val - node.val)
        } else if (node.right) {
            console.log('right')
            return node.right.val - node.val
        } else if (node.left) {
            console.log('left')
            return node.val - node.left.val
        } else {
            return Number.MAX_VALUE
        }
    }

    const preOrder = (root) => {
        if (!root) {
            return 0;
        }
        let x = getMin(root)
        if (x < min)
            min = x
        preOrder(root.left)
        preOrder(root.right)

    }
    preOrder(root)
    return min
};

console.log(minDiffInBST({
        "val": 90,
        "left": {
            "val": 69,
            "left": {"val": 49, "left": null, "right": {"val": 52, "left": null, "right": null}},
            "right": {"val": 89, "left": null, "right": null}
        },
        "right": null
    }

))

var minDiffInBST=函数（根）{
设min=Number.MAX\u值
const getMin=（节点）=>{
if（node.left&&node.right）{
console.log（'both'）
返回Math.min（node.val-node.left.val，node.right.val-node.val）
}else if（node.right）{
console.log（'right'）
返回node.right.val-node.val
}else if（node.left）{
console.log（'left'））
返回node.val-node.left.val
}否则{
返回编号。最大值
}
}
常量前序=（根）=>{
如果（！root）{
返回0；
}
设x=getMin（根）
如果（x

获取输出

3

预期输出

1

问题我被带离这里

---

您需要进行顺序遍历，而不是预顺序遍历

在BST中，按顺序遍历将提供一个排序列表。 在排序列表中，两个元素之间的最小距离将最接近

---

>，先对排序列表进行求解，然后求解BST遍历<>代码> < /COD> < /P> < P>除Paul Nikonowicz评论外，这里是我在C++中的实现，使用顺序遍历来获得BST的排序向量，然后迭代它将每个结果值与向量

的最大值进行比较。

#include<iostream> 
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

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:
    vector<int> toCompare = {};

    /* find min diff pair of our inorder derived vector*/
    int find_min(vector <int> const& a) {
        int diff = *std::max_element(a.begin(), a.end());
        for (int i = 0; i < a.size()-1; i++)
            if (a.at(i + 1) - a.at(i) < diff) {
                diff = a.at(i + 1) - a.at(i);

            }
        return diff;
    }

    int minDiffInBST(TreeNode* root) {
   
        if (root == NULL) {
            return 0;
        };

        /* In order traversal */
        minDiffInBST(root->left);
        /* Storing in vector/list */
        toCompare.push_back(root->val);

        minDiffInBST(root->right);
 
        return find_min(toCompare);    
      
    };
};


int main() {
    struct TreeNode* root = new TreeNode(5);
    root->left = new TreeNode(4);
    root->right = new TreeNode(6);
    root->left->left = new TreeNode(3);
    
    Solution myObj;

    cout << myObj.minDiffInBST(root);
    return 0;

#包括
#包括
#包括
#包括
使用名称空间std；
树状结构{
int-val；
TreeNode*左；
TreeNode*对；
TreeNode（）：val（0），左（nullptr），右（nullptr）{
树节点（intx）：val（x），左（nullptr），右（nullptr）{
树节点（intx，树节点*左，树节点*右）：val（x），左（左），右（右）{
};
类解决方案{
公众：
向量toCompare={}；
/*找到我们的有序导出向量的最小差对*/
int find_min（向量常量和a）{
int diff=*std:：max_元素（a.begin（），a.end（））；
对于（int i=0；i左）；
/*存储在向量/列表中*/
toCompare.push_back（root->val）；
minDiffInBST（根->右）；
返回find_min（toCompare）；
};
};
int main（）{
struct TreeNode*root=新的TreeNode（5）；
根->左=新树节点（4）；
根->右=新树节点（6）；
根->左->左=新树节点（3）；
溶液myObj；
库特