链接

https://leetcode-cn.com/problems/que-shi-de-shu-zi-lcof/
难度： #简单

题目

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

限制：
1 <= 数组长度 <= 10000

代码框架

class Solution {
    public int missingNumber(int[] nums) {

    }
}

题目解析

解答思路1：
暴力解法，for循环，
查看数字是否和数组的下标相同，
如果不相同，则缺少该下标对应的数字，
如果没有找到，则缺失的一定是最后一个数字。

解答思路2：
二分查找法，while循环，
找到第一个不和数组下标相等的数字，
根据low和high计算中间的mid,
如果mid下标对应的数字和mid相等，
则缺失的数字在右边部分，
如果mid下标对应的数字和mid不相等，
则需要进一步确定是否是第一个不相等的数字，
如果mid==0，则左边没有数字了，可以确定缺失的数字，
如果mid-1下标对应的数字和mid相等，也可以确实缺失的数字，
否则缺失的数据在左边部分。

测试用例

package edu.yuwen.sowrd.num53_II.solution;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import edu.yuwen.sowrd.num53_II.sol2.Solution;

public class SolutionTest {
    /**
     * 输入: [0,1,3]
     * 输出: 2
     */
    @Test
    public void testCase1() {
        Solution solution = new Solution();

        int[] nums = { 0, 1, 3 };
        int number = solution.missingNumber(nums);
        Assertions.assertEquals(2, number);
    }

    /**
     * 输入: [0,1,2,3,4,5,6,7,9]
     * 输出: 8
     */
    @Test
    public void testCase2() {
        Solution solution = new Solution();

        int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 9 };
        int number = solution.missingNumber(nums);
        Assertions.assertEquals(8, number);
    }

    /**
     * 输入: [0]
     * 输出: 1
     */
    @Test
    public void testCase3() {
        Solution solution = new Solution();

        int[] nums = { 0 };
        int number = solution.missingNumber(nums);
        Assertions.assertEquals(1, number);
    }
}

解答1

package edu.yuwen.sowrd.num53_II.sol1;

public class Solution {
    public int missingNumber(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i) {
                return i;
            }
        }
        // 如果没有找到，则缺失的一定是最后一个数字
        return nums.length;
    }
}

解答2 推荐

package edu.yuwen.sowrd.num53_II.sol2;

public class Solution {
    public int missingNumber(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;

            // 如果下标和数字相等，则缺失的数字在右边部分
            if (nums[mid] == mid) {
                low = mid + 1;
            }
            // 如果下标和数字不相等，则缺失的数字在左边部分
            if (nums[mid] != mid) {
                // 确保是第一个和下标不相等的数字
                if (mid == 0 || nums[mid - 1] == mid - 1) {
                    return mid;
                }
                high = mid - 1;
            }
        }

        // 如果没有找到，则缺失的一定是最后一个数字
        return nums.length;
    }
}