检查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

算法

• 步骤1 − 声明并初始化一个整数数组。

• 步骤2 − 使用for循环表示子数组的起始和结束位置。

• 步骤3 − 现在检查子数组是否连续。

• 步骤4 − 打印子数组的元素。

语法

要获取数组的长度（数组中元素的数量），数组有一个内置属性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编程语言检查给定数组中是否存在由连续整数形成的子数组的不同方法。