小明思考

private static class Sequence{
        int start;
        int end;
        int length;
    }
    
    public int longestConsecutive(int[] num) {
        int len =0;
        if(num==null || (len=num.length)<1){
            return 0;
        }
        
        Map<Integer,Sequence> start = new HashMap<Integer,Sequence>();
        Map<Integer,Sequence> end = new HashMap<Integer,Sequence>();
        int maxLength = 0;
        
        for(int i=0;i<len;++i){
            Sequence s = null;
            int v = num[i];
            if(start.containsKey(v) || end.containsKey(v)){
                continue;
            }
            if(start.containsKey(v+1)){
                s = start.remove(v+1);
                s.start = v;
                ++s.length;
                while(end.containsKey(s.start-1)){ //merge ends
                    Sequence m = end.remove(s.start-1);
                    start.remove(m.start);
                    s.start = m.start;
                    s.length += m.length;
                }
                start.put(s.start, s);
            }
            else if(end.containsKey(v-1)){
                s = end.remove(v-1);
                s.end = v;
                ++s.length;
                while(start.containsKey(s.end+1)){ //merge starts
                    Sequence m = start.remove(s.end+1);
                    end.remove(m.end);
                    s.end = m.end;
                    s.length += m.length;
                }
                end.put(s.end, s);
            }
            else{
                s = new Sequence();
                s.start = s.end = v;
                s.length = 1;
                start.put(v,s);
                end.put(v,s);
            }
            //System.out.println(i+" "+v+" seqence:"+s.start+"/"+s.end+"/"+s.length);
            if(maxLength<s.length){
                maxLength = s.length;
            }
        }
        
        return maxLength;
    }