[LeetCode]530. Minimum Absolute Difference in BST(BST的最小绝对差)

530. Minimum Absolute Difference in BST

Given a binary search tree with non-negative values, find the minimum absolute difference between values of any two nodes.

Example:

Input:

   1
    \
     3
    /
   2

Output:
1

Explanation:

The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).

Note: There are at least two nodes in this BST.

题目大意：计算BST的任意两个节点的值，返回最小的差。

要做题，首先要明白BST的定义
BST是满足如下3个条件的二叉树：
1. 节点的左子树包含的节点的值小于该节点的值
2. 节点的右子树包含的节点的值大于等于该节点的值
3. 节点的左子树和右子树都是BST
可参考：经典基础算法之BST详解

由定义可知道，通过中序遍历得到一个升序数组，最小的一定在数组中相邻两个元素中产生，便可得到结果。以下是实现代码，用到了递归，空间复杂度O(n),效率也算比较低的

#include <iostream>
#include <vector>
#include <limits.h>
using namespace std;
/**
 * 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:
    int getMinimumDifference(TreeNode* root) {
        if(!root)
            return 0;
        vector<int> InOrderArray;
        getInOrderArray(InOrderArray, root);
        //INT_MAX定义
        //zhidao.baidu.com/question/294243885.html
        int res = INT_MAX;
        for(int i=1; i<InOrderArray.size(); i++){//遍历数组得到相邻两个元素最小的差
            if(InOrderArray[i] - InOrderArray[i-1] < res)
                res = InOrderArray[i] - InOrderArray[i-1];
        }
        return res;
    }
    void getInOrderArray(vector<int> &InOrderArray, TreeNode* root){//通过中序遍历得到一个升序数组
        if(!root)
            return;
        getInOrderArray(InOrderArray, root->left);
        InOrderArray.push_back(root->val);
        getInOrderArray(InOrderArray, root->right);
    }

};
int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

递归效率太低，找了个非递归的方法，思路与递归差不多，用到了栈，关于栈，参考传送门，代码参考了链接

处理第一个节点值时，由于其没有前节点，所以不能求绝对差。这里用变量pre来表示前节点值，这里由于题目中说明了所以节点值不为负数，所以我们给pre初始化-1，这样就知道pre是否存在。

class Solution {
public:
    int getMinimumDifference(TreeNode* root) {
        //res为最小差，pre为前节点值，BST没有负数，所以定义为-1
        int res = INT_MAX, pre = -1;
        //Stack<TreeNode*> InOrderArray = new Stack<>();
        stack<TreeNode*> InOrderArray;//定义一个栈
        TreeNode *p = root;
        while (p || !InOrderArray.empty()) {//非空判断
            while (p) {
                InOrderArray.push(p);
                p = p->left;
            }
            p = InOrderArray.top();//栈顶元素
            InOrderArray.pop();//往下遍历栈
            if (pre != -1) 
                res = min(res, p->val - pre);
            pre = p->val;
            p = p->right;
        }
        return res;
    }
};