缺失数字

  一道简单的题，但是发现了各种有趣的算法。题目链接：https://leetcode-cn.com/problems/missing-number/

  题目如下：

 

第一种算法(很普通，效率最低，将nums数组的数存储在list中，然后循环i从1到数组长度，查询list中不存在的i，即为结果)，代码如下：

        int numsLen = nums.length;
        int result = 0;
        List list = new ArrayList();
        for (int i = 0; i < numsLen; i++) {
            list.add(nums[i]);
        }
        for (int i = 0; i <= numsLen; i++) {
            if (!list.contains(i)) {
                result = i;
                break;
            }
        }
        return result;

第二种算法：和第一种类似，但用到了搜索元素效率更高的hashset，在测试中运行时间仅仅只占第一种算法的1/20，代码如下：

        Set<Integer> numSet = new HashSet<Integer>();
        for (int num : nums) numSet.add(num);
        int expectedNumCount = nums.length + 1;
        //HashSet的查询效率大大高于list的查询效率
        for (int number = 0; number < expectedNumCount; number++) {
            if (!numSet.contains(number)) {
                return number;
            }
        }
        return -1;

第三种算法：思路~未缺失元素时元素的和=0+1+2+...+数组的长度；缺失元素时元素的和=未缺失元素时元素的和-缺失元素 即缺失元素=未缺失元素时元素的和-缺失元素时元素的和，只涉及简单的加减法，效率高，也是一个取巧的算法，代码如下：

        //思路：未缺失元素时元素的和=0+1+2+...+数组的长度；缺失元素时元素的和=未缺失元素时元素的        和-缺失元素
        //即缺失元素=未缺失元素时元素的和-缺失元素时元素的和
        //allSum：未缺失元素时元素的和，almostSum：缺失元素时元素的和
        int allSum = 0, almostSum = 0;
        //未缺失元素时元素的和
        for (int i = 0; i <= nums.length; i++) {
            allSum += i;
        }
        //缺失元素时元素的和
        for (int i = 0; i < nums.length; i++) {
            almostSum += nums[i];
        }
        //缺失元素的值
        return allSum - almostSum;

第四种算法：类似与第三种算法，只是对未缺失元素时元素的和的计算采用了等差数列通项公式求和，再减去所给数组的值即为缺失元素的值，代码如下：

        int numsLen = nums.length;
        int sum = ((1 + numsLen) * numsLen) / 2;
        for (int i = 0; i < numsLen; i++) {
            sum -= nums[i];
        }
        return sum;

四种算法的运行结果如图所示：

  从中我们可以获得启示：（1）不同的数据结构可以给算法带来高效率（2）换一种思路，或许能看到不一样的天空。