java - Java中嵌套循环的类型

Question

我有一个简单的问题。我必须在java中找出尽可能多的嵌套循环。我有类似for循环和if语句的东西。我知道我们可以这样做 if{if{if{if{类似的东西。只需要对更多类型的嵌套循环有更多了解。

如果你能写下一些例子。我会很高兴的。谢谢你。

public class Test {
    public static void main (String []args) {
        int i = 0;

        for(int j = 1; j <= 5; j++) {
            if(j == 1 || j == 5) {
                i = 4;
            } else {
                i = 1;
            }
            for(int x = 0; x < i; x++) {
                System.out.print("**");
            }
            System.out.println();
         }
    }
}

Answer 1

您可以嵌套任意多个 for/while在 Java 中您实际上想要的循环:没有实际限制。

Java 有 4 个循环结构:

JLS 14.14 The for Statement

JLS 14.14.1 The basic for Statement

JLS 14.14.2 The enhanced for Statement (又名“for-each”)

JLS 14.12 The while Statement

JLS 14.13 The do Statement (又名“do-while”)

Java 没有 goto (无论如何都不需要)。

也可以看看

Java Nuts and Bolts/the for Statement

Java language guide/ for-each loop

例子

这是一个简单的“三角形”型嵌套循环的典型示例，其中内循环的迭代次数取决于外循环中正在迭代的值:

for (int i = 1; i <= 5; i++) {     // prints:
   for (int j = 0; j < i; j++) {   // *
      System.out.print("*");       // **
   }                               // ***
   System.out.println();           // ****
}                                  // *****

这是一个“配对”型嵌套循环的示例，其中两个循环相互独立，使用 for-each 构造:

int[] numbers = { 1, 2, 3 };                       // prints:  // if swapped:
char[] letters = { 'A', 'B', 'C' };                // 1 A      // 1 A
                                                   // 1 B      // 2 A
for (int number : numbers) {                       // 1 C      // 3 A
   for (char letter : letters) {                   // 2 A      // 1 B
       System.out.println(number + " " + letter);  // 2 B      // 2 B
   }                                               // 2 C      // 3 B
}                                                  // 3 A      // 1 C
                                                   // 3 B      // 2 C
                                                   // 3 C      // 3 C

for-each缺少显式索引的构造使得两个循环的独立性显而易见:您可以交换两个 for上面代码中的语句，你仍然会得到所有对，尽管以不同的顺序列出。

使用 boolean while 的方法循环(这个来自 java.util.Scanner )是典型的:

Scanner sc = new Scanner("here we go again");     // prints:
while (sc.hasNext()) {                            // hereeeee
   String s = sc.next();                          // weeeee
   char lastChar = s.charAt(s.length() - 1);      // gooooo
   for (int i = 0; i < 4; i++) {                  // againnnnn
      s += lastChar;
   }
   System.out.println(s);
}

这是一个示例，说明 do-while不同于 while-do和 for :

    int x = 0;
    do {
        System.out.println("Hello!!!");
    } while (x != 0);

上面的循环打印 Hello!!! : do-while 的正文在检查终止条件之前执行。

一个更详细的例子

这是一个嵌套循环逻辑的示例，但被重构为方法以使事情更具可读性。这是初学者学习的重要内容:仅仅因为您可以在物理上将循环嵌套任意多的级别，并不意味着您应该 .通过像这样分解逻辑，程序变得更加模块化和可读性，并且每个逻辑都独立存在并且可以测试和重用等。

此片段反转 char[] 中的单词的字母。到位。

static void swap(char[] arr, int i, int j) {
    char t = arr[i];
    arr[i] = arr[j];
    arr[j] = t;
}
static void reverse(char[] arr, int from, int to) {
    int N = (to - from);
    for (int i = 0; i < N / 2; i++) {
        swap(arr, from+i, to-1-i);
    }
}
public static void main(String[] args) {
    char[] sentence = "reversing letters of words in sentence".toCharArray();
    final int L = sentence.length;
    int last = 0;
    for (int i = 0; i <= L; i++) {
        if ((i == L) || (sentence[i] == ' ')) {
            reverse(sentence, last, i);
            last = i + 1;
        }
    }
    System.out.println(new String(sentence));
    // prints "gnisrever srettel fo sdrow ni ecnetnes"
}

这个例子也很有启发性，因为 尽管它本质上是一个嵌套循环算法，但它实际上是 O(N) !认为任何双重嵌套循环算法都必须是 O(N^2) 是错误的。 ——它真的取决于算法本身，而不仅仅是物理结构。

嵌套循环算法

这些是传统上使用嵌套循环实现的经典算法(至少以它们的幼稚形式):

O(N^2)排序算法:

Bubble sort

Selection sort

Insertion sort

O(N^3)三重嵌套循环算法:

Matrix multiplication

填表动态规划算法

Levenshtein distance ( O(N^2) , 字符串编辑距离)

Floyd-Warshall Algorithm (O(N^3)，图中所有对最短路径)

这些远非详尽的抽样，但它应该很好地介绍了各种嵌套 for初学者的循环算法。