在Java中查找给定数组的所有子数组

---

一个数组是一种线性数据结构，其中元素存储在连续的内存位置。

根据问题陈述，我们必须找到给定数组的所有子数组。子数组是数组的一部分或一段。当我们谈论数组的所有子数组时，我们指的是可以使用数组的所有元素进行组合的总数，而无需重复。

让我们探索本文，了解如何使用Java编程语言来完成此操作。

为您展示一些实例

实例 1

假设我们有以下数组

[10, 2, 3, -5, 99, 12, 0, -1]

此数组的子数组将是

10
10 2
10 2 3
10 2 3 -5
10 2 3 -5 99
10 2 3 -5 99 12
10 2 3 -5 99 12 0
10 2 3 -5 99 12 0 -1
2
2 3
2 3 -5
2 3 -5 99
2 3 -5 99 12
2 3 -5 99 12 0
2 3 -5 99 12 0 -1
3
3 -5
3 -5 99
3 -5 99 12
3 -5 99 12 0
3 -5 99 12 0 -1
-5
-5 99
-5 99 12
-5 99 12 0
-5 99 12 0 -1
99
99 12
99 12 0
99 12 0 -1
12
12 0
12 0 -1
0
0 -1
-1

实例 2

假设我们有以下数组

[55,10,29,74]

此数组的子数组将是

55
55 10
55 10 29
55 10 29 74
10
10 29
10 29 74
29
29 74
74

算法

算法 1

• 步骤 1 - 存储数组后，运行一个从 0 到 n 的 for 循环。这将标记我们主数组的起始点。

• 步骤 2 - 运行另一个 for 循环，该循环从第一个迭代器运行到主数组的结束点。

• 步骤 3 - 现在运行另一个循环，遍历这两个迭代器之间的元素。

• 步骤 4 - 按顺序打印元素。

算法 2

• 步骤 1 - 存储数组后，检查我们是否已到达末尾，然后退出函数。

• 步骤 2 - 如果起始索引大于结束索引，则从 0 到 end+1 自行调用函数。

• 步骤 3 - 否则，在 for 循环内打印索引之间的数组元素，然后从 start+1 到 end 再次调用函数。

• 步骤 4 - 退出。

语法

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

下面指的是它的语法：

array.length

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

您可以使用 Arrays.sort() 方法将数组按升序排序。

Arrays.sort(array_name);

多种方法

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

• 使用 for 循环

• 使用递归

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

方法 1：使用 for 循环

在这种方法中，我们将使用三个 for 循环来查找数组的子数组。第一个循环标记开始，第二个循环标记子数组的结束，而第三个循环打印子数组。

示例

import java.io.*;
public class Main {
   public static void main(String[] args) {
      
      // The array elements
      int arr[] = { 10, 2, 3, 99, 12, 0 };
      System.out.println("The subarrays are-");
      
      // For loop for start index
      for (int i = 0; i < arr.length; i++)
      
      // For loop for end index
      for (int j = i; j < arr.length; j++) {
      
         // For loop to print subarray elements
         for (int k = i; k <=j; k++)
            System.out.print(arr[k] + " ");
            System.out.println("");
      }
   }
}

输出

The subarrays are-
10 
10 2 
10 2 3 
10 2 3 99 
10 2 3 99 12 
10 2 3 99 12 0 
2 
2 3 
2 3 99 
2 3 99 12 
2 3 99 12 0 
3 3 99 3 99 12 3 99 12 0 
99 
99 12 
99 12 0 
12 12 0 
0 

方法 2：使用递归

在这种方法中，我们使用递归查找所有子数组。

示例

import java.io.*;
public class Main {
   //main method
   public static void main(String[] args) {
      // The array elements
      int arr[] = { 10, 2, 3};
      System.out.println("The subarrays are-");
         
      // Calling the recursive function
      printSubArrays(arr, 0, 0);
   }
   
   // Recursive FUnction to Find all the subarrays
   static void printSubArrays(int[] arr, int head, int tail) {
   
      // Exits the function if we have reached the end
      if (tail == arr.length)
         return;
      
      // Increases the first index and calls itself
      else if (head > tail)
         printSubArrays(arr, 0, tail + 1);
      
      // Print the subarray and then increases the first element index
      else {
         for (int i = head; i < tail; i++)
            System.out.print(arr[i] + " ");
         System.out.println(arr[tail]);
         printSubArrays(arr, head + 1, tail);
      }
      return;
   }
}

输出

The subarrays are-
10
10 2
2
10 2 3
2 3
3

在本文中，我们探讨了如何使用 Java 编程语言查找给定数组的所有子数组。