最长连续序列letcode

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

package com.yunlong.test;


import java.util.*;

public class SerMaxSubArray {
    public static void main(String[] args) {
        int[] nums = {9,1,-3,2,4,8,3,-1,6,-2,-4,7};
        longestConsecutive(nums);
    }

    public static int longestConsecutive(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int[] inst = removeMulti(nums);
        sort(inst, 0, inst.length - 1);
        return getlongest(inst);
    }

    public static int getlongest(int[] arr) {
        int max = 1;
        int len = 1;
        for (int i = 0; i <= arr.length - 2; i++) {
            if (arr[i] + 1 == arr[i + 1]) {
                len++;
            } else {
                if (max < len) {
                    max = len;
                }
                len = 1;
            }
            if (i == arr.length - 2) {
                if (max < len) {
                    max = len;
                }
            }
        }
        // list.stream().mapToInt(Integer::intValue).max().getAsInt()
        // java.util.NoSuchElementException: No value present 需要判断isPresent()
        return max;
    }

    // 快速排序 Arrays.stream(arr).sorted().toArray() api排序
    public static void sort(int[] arr, int left, int right) {
        if (left > right) return;
        int i,j,temp,t;
        i = left;
        j = right;
        //temp就是基准位
        temp = arr[left];

        while (i < j) {
            // 先右递减后左递加（必须先右后左）
            while (temp <= arr[j] && i < j) {
                j--;
            }
            while (temp >= arr[i] && i < j) {
                i++;
            }
            //如果满足条件则交换
            if (i < j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[left] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        sort(arr, left, j-1);
        //递归调用右半数组
        sort(arr, j+1, right);
    }

    // 数组去重
    public static int[] removeMulti(int[] arr) {
        Set<Integer> set = new HashSet<>();
        Arrays.stream(arr).forEach(t->{set.add(t);});
        Integer[] ints  = set.toArray(new Integer[]{});
        int[] res = new int[ints.length];
        // 转为int[]
        for (int i = 0; i < ints.length; i++) {
            res[i] = ints[i].intValue();
        }
        return res;
    }
}

然而效率并不高。
和官方相比，简直不忍直视。

1、set集合我只拿来去重，因为他的排序是不靠谱的，比如：100,4,200,1,3,2,5,8；排序后的结构：1,2,3,100,4,5,200,8。这让我想到去重后，用快排排序。
2、还是核心判断规则，设置有问题。需要排序才能判断。

官方代码：

class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> num_set = new HashSet<Integer>();
        for (int num : nums) {
            num_set.add(num);
        }

        int longestStreak = 0;

        for (int num : num_set) {
            if (!num_set.contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;

                while (num_set.contains(currentNum + 1)) {
                    currentNum += 1;
                    currentStreak += 1;
                }

                longestStreak = Math.max(longestStreak, currentStreak);
            }
        }

        return longestStreak;
    }
}