檢查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程式語言檢查給定陣列中是否存在由連續整數形成的子陣列的不同方法。