小于n的最大数

给定一个数n，如23121；给定一组数字A，如{2,4,9}，求由A中元素组成的、小于n的最大数，如小于23121的最大数为22999。

import java.util.Arrays;

public class Solution {

    public static void main(String[] args) {
        int[] nums = new int[]{2, 4, 9};
        System.out.println(getMaxNum(nums, 23121));
    }

    public static int getMaxNum(int[] nums, int digit) {
        StringBuilder result = new StringBuilder();
        //对nums排序
        Arrays.sort(nums);
        String digitStr = String.valueOf(digit);
        //用于标记后面的位数是否可以直接取最大值
        boolean flag = false;
        for (int i = 0; i < digitStr.length(); i++) {
            if (flag) {
                result.append(nums[nums.length - 1]);
                continue;
            }
            int target = digitStr.charAt(i) - '0';
            if (i == digitStr.length() - 1) {
                target = target - 1;
            }
            //搜索nums中最接近的小于等于target的数
            int temp = search(nums, target);
            //当前位不存在小于等于target的数
            if (temp == -1) {
                //现在正处于第一位，则说明后面的位直接取最大值即可，当前位不取值
                if (i == 0) {
                    flag = true;
                } else {//现在处于后面的位，则需要依次回溯前面位，继续往小了取
                    // 从上一位开始，取一个更小的数
                    int index = i - 1;
                    while (temp == -1 && index >= 0) {
                        temp = search(nums, result.charAt(index) - '0' - 1);
                        //由于上一位必定要换一个数填，则直接从result中删除
                        result.deleteCharAt(index);
                        index--;
                    }
                    //前面所有位都找不到更小的数了，则最终结果就是除了第一位，后面位全部取最大值
                    if (temp == -1) {
                        i = 0;
                    } else {//此时说明回溯时某一位找到更小的值了，则此时后面所有位都应该是最大值
                        result.append(temp);
                        //从找到更小数的这位的下一位开始，一直到i，都赋成最大值。由于之前index多减了一次，所以这里是index+2
                        for (int j = index + 2; j <= i; j++) {
                            result.append(nums[nums.length - 1]);
                        }
                    }
                    flag = true;
                }

            } else {//当前位存在小于等于target的数
                result.append(temp);
                if (temp < target) {
                    flag = true;
                } 
            }

        }
        return result.length() != 0 ? Integer.parseInt(result.toString()) : -1;
    }

    public static int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left + 1) / 2;
            if (nums[mid] <= target) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        return nums[left] <= target ? nums[left] : -1;
    }
}