Java 检查一个数组中是否有连续整数构成的子数组

在Java中，数组是一个对象。它是一种非原始数据类型，用于存储相同数据类型的值。

根据问题的陈述，我们需要检查一个子数组是否由给定整数数组中的连续整数组成。子数组指的是数组的某一段。在这里，要检查由连续整数元素组成的子数组，即数组元素是一系列连续的数字，我们可以按照顺序得到一个接一个元素。

让我们来探讨一下这篇文章，看看如何使用Java编程语言来解决这个问题。

给你一些实例

实例-1

Suppose the original array is {8, 0, 2, 4, 1, 3, 1, 9, 5, 11}
After finding the sub array the result will be:
The largest subarray is from index [1, 5]
The elements of subarray are: 0 2 4 1 3

实例-2

Suppose the original array is {9, 7, 3, 2, 0, 2, 18, 0}
After finding the sub array the result will be:
The largest subarray is from index [2, 3]
The elements of subarray are: 3 2

实例-3

Suppose the original array is {0, 2, 1, 3, 5, 4, 5, 11}
After finding the sub array the result will be:
The largest subarray is from index [0, 5]
The elements of subarray are: 0 2 1 3 5 4

步骤

• 第一步 - 声明并初始化一个整数数组。

• 第二步 - 使用for循环表示子数组的起始和结束位置。

• 第三步 - 检查子数组是否连续。

• 第四步 - 打印子数组的元素。

语法

要获取数组的长度（数组中的元素数量），可以使用数组的内置属性length。

以下是其语法参考：

array. length

其中，’array’指的是数组引用。

多种方法

我们以不同的方法提供了解决方案。

• 通过使用数组的静态初始化

• 通过使用用户定义的方法

让我们逐个查看程序及其输出。

方法1：通过使用数组的静态初始化

在这种方法中，数组元素将在程序中初始化。然后根据算法检查是否由给定整数数组的连续整数形成子数组。

示例

import java.lang.*;
public class Main {
   public static void main (String[] args) {
      int[] A = { 0, 12, 14, 13, 45, 41, 5, 11 };
      int len = 1;
      int start = 0, end = 0;
      for (int i = 0; i < A.length - 1; i++) {
         int min_val = A[i], max_val = A[i];
         for (int j = i + 1; j < A.length; j++) {
            min_val = Math.min(min_val, A[j]);
            max_val = Math.max(max_val, A[j]);
            if (isConsecutive(A, i, j, min_val, max_val)) {
               if (len < max_val - min_val + 1) {
                   len = max_val - min_val + 1;
                   start = i;
                   end = j;
               }
            }
         }
      }
      System.out.println("The largest subarray is from index ["+start + "," + end + "]");
      System.out.print("The elements of subarray are: ");
      for (int x = start; x <= end; x++) {
         System.out.print(A[x]+" ");
      }
   }
   private static boolean isConsecutive(int[] A, int i, int j, int min, int max) {
      if (max - min != j - i) {
         return false;
      }
      boolean visited[] = new boolean[j - i + 1];
      for (int k = i; k <= j; k++) {
         if (visited[A[k] - min]) {
            return false;
         }
         visited[A[k] - min] = true;
      }
      return true;
   }
}

输出

The largest subarray is from index [1,3]
The elements of subarray are: 12 14 13

示例

import java.lang.*;
public class Main {
   public static void main (String[] args) {
      int[] A = { 9, 4, 3, 1, 0, 2, 18, 0 };
      findMaxSubarray(A);
   }
   public static void findMaxSubarray(int[] A) {
      int len = 1;
      int start = 0, end = 0;
      for (int i = 0; i < A.length - 1; i++) {
         int min_val = A[i], max_val = A[i];
         for (int j = i + 1; j < A.length; j++) {
            min_val = Math.min(min_val, A[j]);
            max_val = Math.max(max_val, A[j]);
            if (isConsecutive(A, i, j, min_val, max_val)) {
               if (len < max_val - min_val + 1) {
                  len = max_val - min_val + 1;
                  start = i;
                  end = j;
               }
            }
         }
      }
      System.out.println("The largest subarray is from index [" +start + "," + end + "]");
      System.out.print("The elements of subarray are: ");
      for (int x = start; x <= end; x++) {
         System.out.print(A[x]+" ");
      }
   }
   private static boolean isConsecutive(int[] A, int i, int j, int min, int max) {
      if (max - min != j - i) {
         return false;
      }
      boolean visited[] = new boolean[j - i + 1];
      for (int k = i; k <= j; k++) {
         if (visited[A[k] - min]) {
            return false;
         }
         visited[A[k] - min] = true;
      }
      return true;
   }
}

输出

The largest subarray is from index [1,5]
The elements of subarray are: 4 3 1 0 2

在本文中，我们使用Java编程语言探讨了不同的方法来检查一个子数组是否由给定数组中的连续整数组成。