在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步 – 打印子数组的元素。

语法

要获得一个数组的长度（该数组中的元素数），有一个数组的内置属性，即长度

下面是它的语法

array. length

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

多种方法

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

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

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

让我们逐一看看这个程序和它的输出。

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

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

例子

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编程语言来检查一个子数组是否由给定数组中的连续整数组成。