Missing Ranges

[分析]
此题若不考虑极大值极小值相关的corner case是简单的，如base version，当前leetcode的test case没有包含这些边缘case，因此是可以通过的。下面给出两种实现，base version和做了防溢出处理的robust version，并提供了相应的test case。
遇到整数数组问题，需要特别留意溢出问题，面试时可先写出base version然后再考虑增加放溢出处理，不然后者可能严重干扰主干思路，对我来说，添加上防溢出处理的时间远多于写出base version的时间。

public class MissingRanges {

    @Test
    public void testMissingRanges() {
        MissingRanges obj = new MissingRanges();
        List<String> expect = new ArrayList<String>();
        // case 1
        expect.add("-1->2147483646");
        int[] nums = {Integer.MAX_VALUE};
        List<String> actual1 = obj.findMissingRanges1(nums, -1, Integer.MAX_VALUE);
        List<String> actual2= obj.findMissingRanges2(nums, -1, Integer.MAX_VALUE);
        Assert.assertEquals(false, checker(expect, actual1));
        Assert.assertEquals(true, checker(expect, actual2));
        
        // case2
        expect.clear();
        int[] nums2 = {Integer.MAX_VALUE};
        List<String> actual3 = obj.findMissingRanges1(nums2, Integer.MAX_VALUE, Integer.MAX_VALUE);
        List<String>  actual4= obj.findMissingRanges2(nums2, Integer.MAX_VALUE, Integer.MAX_VALUE);
        Assert.assertEquals(false, checker(expect, actual3));
        Assert.assertEquals(true, checker(expect, actual4));
    }
    public boolean checker(List<String> expect, List<String> actual) {
        if (expect.size() != actual.size())
            return false;
        for (int i = 0; i < expect.size(); i++) {
            if (!expect.get(i).equals(actual.get(i)))
                return false;
        }
        return true;
    }
    // more robust version, take care of overflow edge case 
    public List<String> findMissingRanges2(int[] nums, int lower, int upper) {
        List<String> ret = new ArrayList<String>();
        if (nums == null)
            return ret;
        for (int i = 0; i < nums.length; i++) {
            if (lower < nums[i]) {
                if (lower < nums[i] - 1) {// avoid overflow
                    ret.add("" + lower + "->" + (nums[i] - 1));
                } else {
                    ret.add(String.valueOf(lower));
                }
            }
            if (nums[i] < Integer.MAX_VALUE) // avoid overflow
                lower = nums[i] + 1;
            else
                lower = Integer.MAX_VALUE;
        }
        // process lower==upper for case like: [-1], -1, 0
        // 添加nums[nums.length -1] != Integer.MAX_VALUE 这个判断，考虑case：
        // [Integer.MAX_VALUE], Integer.MAX_VALUE, Integer.MAX_VALUE
        if (lower < upper) {
            ret.add("" + lower + "->" + upper);
        } else if (lower == upper && !(nums.length > 0 && nums[nums.length -1] == Integer.MAX_VALUE))  {
            ret.add(String.valueOf(lower));
        }
        return ret;
    }
    
    // base version
    public List<String> findMissingRanges1(int[] nums, int lower, int upper) {
        List<String> ret = new ArrayList<String>();
        if (nums == null)
            return ret;
        for (int i = 0; i < nums.length; i++) {
            if (lower < nums[i]) {
                if (nums[i] - lower > 1) {
                    ret.add("" + lower + "->" + (nums[i] - 1));
                } else {
                    ret.add(String.valueOf(lower));
                }
            }
            lower = nums[i] + 1;
        }
        if (lower < upper) {
            ret.add("" + lower + "->" + upper);
        } else if (lower == upper) {
            ret.add(String.valueOf(lower));
        }
        return ret;
    }
}