java - 最大的连续子序列，返回子序列和长度

我有一个返回子序列长度的函数，但是我也需要返回子序列本身，但是我很难使它起作用。

我已经尝试了以下代码，但是如果它是最长的第一个子序列，则子序列只能正确返回。

如果我使用以下数组，则长度为10是正确的，但它返回的错误子序列为[1、2、3、4、10、11、12、13、14、15]

        int n = arr.length;


        HashSet<Integer> S = new HashSet<Integer>();
        HashSet<Integer> Seq = new HashSet<Integer>();
        int ans = 0;

        // Hash all the array elements
        for (int i = 0; i < n; i++) {
            S.add(arr[i]);
        }
        System.out.println(S);
        // check each possible sequence from the start
        // then update optimal length
        for (int i = 0; i < n; ++i)
        {
            System.out.println("ARR " + i);

            // if current element is the starting
            // element of a sequence
            if (!S.contains(arr[i]-1))
            {
                //System.out.println("INSIDE .CONTAINS");
                // Then check for next elements in the
                // sequence
                int j = arr[i];
                int t = 0;
                while (S.contains(j)) {
                    System.out.println("ANS " + ans);
                    t++;
                    if (t > ans ) { Seq.add(j);}
                    j++;
                   // System.out.println("T " + t);

                  //  System.out.println("SEQ <<<<<<< " + Seq );
                }
                // update  optimal length if this length
                // is more
                if (ans < j-arr[i]) {
                    ans = j-arr[i];
                }
            }
        }
        System.out.println(Seq);
        System.out.println(ans);

        return ans;

最佳答案

这似乎是确定序列的一种round回的方式。

我相信您的缺点之一在这里：

// if current element is the starting
// element of a sequence
if (!S.contains(arr[i]-1))
{

这肯定是有缺陷的。
假设您有输入序列{1,3,5,2,4,6}。该列表中没有2个或更多的序列。但是，输入2到6将通过您的S.contains(arr[i]-1)测试，因为S HashSet包含1,2,3,4,5,6。

这是我认为找到最长序列的更简单方法：

int longestLength = 0;
int longestStart = 0;
int currentStart = 0;
int currentLength = 1;

for(int i=1;i<arr.length;i++)
{
     if (arr[i] == arr[i-1] + 1)
     {
         // this element is in sequence.
         currentLength++;
         if (currentLength > longestLength)
         {
             longestLength = currentLength;
             longestStart = currentStart;
         }
     }
     else
     {
          // This element is not in sequence.
         currentStart = i;
         currentLength = 1;
     }
}
System.out.printlng(longestStart + ", " + longestLength);

关于java - 最大的连续子序列，返回子序列和长度，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/60775423/