我有一个简单的问题.我必须在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();
}
}
}
您可以在Java中嵌套尽可能多的for/ while循环:没有实际限制.
Java有4个循环结构:
for声明
for声明for声明(又名" for-each")while声明do声明(又名" do-while")Java没有goto(无论如何都不需要).
这是一个简单的"三角形"类型嵌套循环的典型示例,其中内循环的迭代次数取决于外循环中迭代的值:
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-dofor
int x = 0;
do {
System.out.println("Hello!!!");
} while (x != 0);
上面的循环打印Hello!!!:在do-while检查终止条件之前执行a的主体.
这是一个嵌套循环逻辑的示例,但重构为方法以使事物更具可读性.这对于初学者来说很重要:只是因为你可以根据需要在物理上嵌套循环,并不意味着你应该这样做.通过拆分这样的逻辑,程序变得更加模块化和可读,并且每个逻辑都独立存在,可以进行测试和重用等.
此片段会反转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) 排序算法:
O(N^3) 三重嵌套循环算法:
O(N^2),字符串编辑距离)O(N^3)中所有对最短路径)这些都不是详尽的抽样,但它应该for为初学者提供各种嵌套循环算法的良好介绍.