给你一个整数数组 nums ，数组由若干 互不相同 的整数组成。

给你一个整数数组 nums ，数组由若干 互不相同 的整数组成。
数组 nums 原本包含了某个范围内的 所有整数 。但现在，其中可能 缺失 部分整数。
该范围内的 最小 整数和 最大 整数仍然存在于 nums 中。
返回一个 有序 列表，包含该范围内缺失的所有整数，并 按从小到大排序。如果没有缺失的整数，返回一个 空 列表。
示例 1：
输入： nums = [1,4,2,5]
输出： [3]
解释：
最小整数为 1，最大整数为 5，因此完整的范围应为 [1,2,3,4,5]。其中只有 3 缺失。
示例 2：
输入： nums = [7,8,6,9]
输出： []
解释：
最小整数为 6，最大整数为 9，因此完整的范围为 [6,7,8,9]。所有整数均已存在，因此没有缺失的整数。
示例 3：
输入： nums = [5,1]
输出： [2,3,4]
解释：
最小整数为 1，最大整数为 5，因此完整的范围应为 [1,2,3,4,5]。缺失的整数为 2、3 和 4。
提示：
2 <= nums.length <= 100
1 <= nums[i] <= 100

点击查看代码

public static void main(String[] args) {
        int[] nums = {5,1};
        int length = nums.length;
        quickSort(nums, 0, length - 1);
        int max = nums[length - 1];
        int min = nums[0];
        int resultLength = max - min + 1;
        List<Integer> results = new ArrayList<>();
        int index = 0;
        for (int i = 0; i < resultLength; i++) {
            if(min + i ==nums[index]){
                index++;
            }else{
                results.add(min+i);
            }
        }


    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low >= high) return;

        int pivot = arr[low]; // 保存基准值（挖坑）
        int i = low;
        int j = high;

        while (i < j) {
            // 从右往左找比 pivot 小的数
            while (i < j && arr[j] >= pivot) j--;
            // 找到了，填入左边的坑，arr[j] 位置变成了新坑
            if (i < j) arr[i++] = arr[j];

            // 从左往右找比 pivot 大的数
            while (i < j && arr[i] <= pivot) i++;
            // 找到了，填入右边的坑，arr[i] 位置变成了新坑
            if (i < j) arr[j--] = arr[i];
        }

        // 循环结束，i == j，这是最后一个坑，将基准值填入
        arr[i] = pivot;

        // 递归左右两边
        quickSort(arr, low, i - 1);
        quickSort(arr, i + 1, high);
    }