public static void main(String[] args) {
        int [] nums ={8,20,28,74,92,188,372,500};
        int targetNumber = 28;
        int i = binarySearch(targetNumber, 0, nums.length, nums);
        System.out.println(i);
    }
        /**
     * 二分查找
     *
     * @param targetNumber 要查找的目标数字
     * @param beginIndex 查找区间的起始下标
     * @param endIndex 查找区间的结束下标
     * @param nums 给定的已排序数组
     * @return 如果找到目标数字，返回目标数字的下标；否则返回 -1
     */
    public static int binarySearch(int targetNumber, int beginIndex, int endIndex, int[] nums) {
        // 计算中间位置
        int middleIndex = (beginIndex + endIndex) / 2;
        // 如果找到目标数字，返回目标数字的下标
        if (targetNumber == nums[middleIndex]) {
            return middleIndex;
        }
        // 如果目标数字比中间位置的数大，说明目标数字在右半区间
        if (targetNumber > nums[middleIndex]) {
            return binarySearch(targetNumber, middleIndex, endIndex, nums);
        }
        // 如果目标数字比中间位置的数小，说明目标数字在左半区间
        return binarySearch(targetNumber, beginIndex, middleIndex, nums);
    }

树中节点的数目在范围 [1, 100] 内
-100 <= Node.val <= 100

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public static TreeNode constructTree(int[] nums) {
    if (nums == null || nums.length == 0) {
        return null;
    }
    // 创建根节点
    TreeNode root = new TreeNode(nums[0]);  
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    int i = 1;
    while (i < nums.length) {
        // 取出队头元素
        TreeNode parent = queue.poll();  
        if (i < nums.length && nums[i] != null) {
            // 创建左子节点
            parent.left = new TreeNode(nums[i]);  
            queue.offer(parent.left);
        }
        i++;
        if (i < nums.length && nums[i] != null) {
            // 创建右子节点
            parent.right = new TreeNode(nums[i]);  
            queue.offer(parent.right);
        }
        i++;
    }
    return root;
}

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        // 用于保存所有从根节点到叶子节点的路径
        List<String> result = new ArrayList<String>();  
        // 处理特殊情况，如果根节点为空，则返回空路径列表
        if (root == null) {  
            return result;
        }
        // 开始深度优先搜索
        dfs(root, new StringBuilder(), result);  
        return result;
    }
    private void dfs(TreeNode node, StringBuilder path, List<String> result) {
        // 如果当前节点为空，返回
        if (node == null) {  
            return;
        }
        // 保存当前路径的长度
        int len = path.length();  
        // 如果当前节点是叶子节点，则将当前路径添加到结果列表中
        if (node.left == null && node.right == null) {  
            result.add(path.append(node.val).toString());
            // 恢复当前路径的长度
            path.setLength(len);  
            return;
        }
        // 将当前节点添加到路径中，并加上箭头
        path.append(node.val).append("->");  
        // 递归遍历左子树
        dfs(node.left, path, result);
        // 递归遍历右子树  
        dfs(node.right, path, result);
        // 恢复当前路径的长度  
        path.setLength(len);  
    }
}