关于二叉树的数值运算，一般考虑借用中序遍历为数组；再进行计算的思想。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    /*定义两个私有变量
    最小的绝对值差
    当前节点的前一个节点
    */
    private int minDiff=Integer.MAX_VALUE;
    private TreeNode preNode =null;
    public int getMinimumDifference(TreeNode root) {
        /*中序遍历*/
        inOrder(root);
        return minDiff;
    }
    public void inOrder(TreeNode node){
        if(node==null) return ;
        //遍历左节点
        inOrder(node.left);
        //前节点不为空，找到最小绝对值差
        if(preNode!=null) minDiff=Math.min(minDiff,node.val-preNode.val);
        //更新前节点
        preNode=node;
        //中序遍历右节点
        inOrder(node.right);
        
    }
}

使用中序遍历得到有序数组之后，再利用双指针对数组进行查找。

应该注意到，这一题不能用分别在左右子树两部分来处理这种思想，因为两个待求的节点可能分别在左右子树中。

public boolean findTarget(TreeNode root, int k) {
    List<Integer> nums = new ArrayList<>();
    inOrder(root, nums);
    int i = 0, j = nums.size() - 1;
    while (i < j) {
        int sum = nums.get(i) + nums.get(j);
        if (sum == k) return true;
        if (sum < k) i++;
        else j--;
    }
    return false;
}

private void inOrder(TreeNode root, List<Integer> nums) {
    if (root == null) return;
    inOrder(root.left, nums);
    nums.add(root.val);
    inOrder(root.right, nums);
}

采用中序遍历的思想；需要用到的变量太多。 还要注意数据转换。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    /*中序遍历：定义一个保存当前节点出现次数的常量curcount;
                定义一个表示数组中元素出现次数最多的常量maxcount
                定义一个表示当前节点的前一个节点的树元素preNode;方便与后一个元素比较
                定义一个数组保存出现次数最多（可以重复）的数组 maxNumList
                */
    private int curcount=1;
    private int maxcount=1;
    private TreeNode preNode=null;
    public int[] findMode(TreeNode root) {
        /*中序遍历；保存当前满足条件的元素*/
        List<Integer> maxNumList=new ArrayList<>();
        inOrder(root,maxNumList);
        /*转换数据结构*/
        int index=0;
        int[] res=new int[maxNumList.size()];
        for(int num:maxNumList){
            res[index++]=num;
        }
        return res;
    }
    public void inOrder(TreeNode node,List<Integer> nums){
        if(node==null) return;
        inOrder(node.left,nums);
        if(preNode!=null){
            if(preNode.val==node.val){
                curcount++;
            }else{
                curcount=1;
            }
        }
        if(curcount>maxcount){
            maxcount=curcount;
            nums.clear();
            nums.add(node.val);
        }else if(curcount==maxcount){
            nums.add(node.val);
        }
        preNode=node;
        inOrder(node.right,nums);
    }
    
}