bug解决：AssertionError: No inf checks were recorded for this optimizer.

介绍

中序遍历：左子树 -> 中 -> 右子树

二叉搜索树：中序遍历可以得到有序的序列

递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public int KthSmallest(TreeNode root, int k) {
        // 辅助结构，当 k == 1 时 表示访问到 第 k个最小的元素
        int[] aux = new int[] { k };
        return Traverse(root, aux);    
    }

    // 递归访问
    public int Traverse(TreeNode node, int[] aux) {
        if(node == null)
        {
            // 用 -1 表示访问到终点
            return -1;
        }

        // 先访问左子树
        {
            var val = Traverse(node.left, aux);
            if(val != -1)
            {
                return val;
            }
        }

        // 访问该节点
        {
            if(aux[0] == 1)
            {
                // 结果
                return node.val;
            }
            aux[0]--;
        }

        // 后访问右子树
        {
            var val = Traverse(node.right, aux);
            if(val != -1)
            {
                return val;
            }
        }

        // 这里是不会走到的根据题意
        return -1;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public int KthSmallest(TreeNode root, int k) {
        // 辅助结构，当 k == 1 时 表示访问到 第 k个最小的元素
        int aux = k;
        return Traverse(root, ref aux);    
    }

    // 递归访问
    public int Traverse(TreeNode node, ref int aux) {
        if(node == null)
        {
            // 用 -1 表示访问到终点
            return -1;
        }

        // 先访问左子树
        {
            var val = Traverse(node.left, ref aux);
            if(val != -1)
            {
                return val;
            }
        }

        // 访问该节点
        {
            if(aux == 1)
            {
                // 结果
                return node.val;
            }
            aux--;
        }

        // 后访问右子树
        // {
        //     var val = Traverse(node.right, ref aux);
        //     if(val != -1)
        //     {
        //         return val;
        //     }
        // }

        // // 这里是不会走到的根据题意
        // return -1;

        // 一个优化，这里直接返回，如果没找到这里就返回-1
        return Traverse(node.right, ref aux);
    }
}

迭代法