数组的各种遍历

已于 2023-04-23 12:54:48 修改
阅读量336 收藏
点赞数
文章标签： java
于 2021-08-21 10:24:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37646636/article/details/119835229
版权

数组的各种组合循环

以如下数组为例

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

1. 正序循环：

		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}

		for (int i = 0; i <= arr.length - 1; i++) {
			System.out.print(arr[i] + "  ");
		}

1  2  3  4  5  6  7  8  9  10  11

2. 倒叙循环：

		for (int i = arr.length - 1; i > -1; i--) {
			System.out.print(arr[i] + "  ");
		}

		for (int i = arr.length - 1; i >= 0; i--) {
			System.out.print(arr[i] + "  ");
		}

11  10  9  8  7  6  5  4  3  2  1

3. 正序循环迭代N次：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j< arr.length; j++) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11

在这里插入图片描述

3.1 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1 - i; j < arr.length; j++) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

精髓：
需要理解这个公式的作用：arr.length - 1 - i
i 取值范围【0， arr.length - 1】决定了
arr.length - 1 - i 取值范围 【arr.length - 1，0】
且一一对应

11  
10  11  
9  10  11  
8  9  10  11  
7  8  9  10  11  
6  7  8  9  10  11  
5  6  7  8  9  10  11  
4  5  6  7  8  9  10  11  
3  4  5  6  7  8  9  10  11  
2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  11

3.2 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j < arr.length; j++) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

1  2  3  4  5  6  7  8  9  10  11  
2  3  4  5  6  7  8  9  10  11  
3  4  5  6  7  8  9  10  11  
4  5  6  7  8  9  10  11  
5  6  7  8  9  10  11  
6  7  8  9  10  11  
7  8  9  10  11  
8  9  10  11  
9  10  11  
10  11  
11

3.3：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= i; j++) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

需要理解 j <= i

1  
1  2  
1  2  3  
1  2  3  4  
1  2  3  4  5  
1  2  3  4  5  6  
1  2  3  4  5  6  7  
1  2  3  4  5  6  7  8  
1  2  3  4  5  6  7  8  9  
1  2  3  4  5  6  7  8  9  10  
1  2  3  4  5  6  7  8  9  10  11

3.4 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i; j++) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

主要理解 j < arr.length-i
也可以写成 j < = arr.length - 1- i

1  2  3  4  5  6  7  8  9  10  11  
1  2  3  4  5  6  7  8  9  10  
1  2  3  4  5  6  7  8  9  
1  2  3  4  5  6  7  8  
1  2  3  4  5  6  7  
1  2  3  4  5  6  
1  2  3  4  5  
1  2  3  4  
1  2  3  
1  2  
1

4. 倒序循环迭代N次：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1; j >= 0; j--) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1

在这里插入图片描述

4.1 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j >= 0; j--) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

1  
2  1  
3  2  1  
4  3  2  1  
5  4  3  2  1  
6  5  4  3  2  1  
7  6  5  4  3  2  1  
8  7  6  5  4  3  2  1  
9  8  7  6  5  4  3  2  1  
10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  1

4.2 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1 - i; j >= 0; j--) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

11  10  9  8  7  6  5  4  3  2  1  
10  9  8  7  6  5  4  3  2  1  
9  8  7  6  5  4  3  2  1  
8  7  6  5  4  3  2  1  
7  6  5  4  3  2  1  
6  5  4  3  2  1  
5  4  3  2  1  
4  3  2  1  
3  2  1  
2  1  
1

4.3 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1; j >= arr.length - 1 - i; j--) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

11  
11  10  
11  10  9  
11  10  9  8  
11  10  9  8  7  
11  10  9  8  7  6  
11  10  9  8  7  6  5  
11  10  9  8  7  6  5  4  
11  10  9  8  7  6  5  4  3  
11  10  9  8  7  6  5  4  3  2  
11  10  9  8  7  6  5  4  3  2  1

4.4 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1; j >= i; j--) {
				System.out.print(arr[j] + "  ");
			}
			System.out.println();
		}

11  10  9  8  7  6  5  4  3  2  1  
11  10  9  8  7  6  5  4  3  2  
11  10  9  8  7  6  5  4  3  
11  10  9  8  7  6  5  4  
11  10  9  8  7  6  5  
11  10  9  8  7  6  
11  10  9  8  7  
11  10  9  8  
11  10  9  
11  10  
11

5. 立序循环迭代N次：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

1  1  1  1  1  1  1  1  1  1  1  
2  2  2  2  2  2  2  2  2  2  2  
3  3  3  3  3  3  3  3  3  3  3  
4  4  4  4  4  4  4  4  4  4  4  
5  5  5  5  5  5  5  5  5  5  5  
6  6  6  6  6  6  6  6  6  6  6  
7  7  7  7  7  7  7  7  7  7  7  
8  8  8  8  8  8  8  8  8  8  8  
9  9  9  9  9  9  9  9  9  9  9  
10  10  10  10  10  10  10  10  10  10  10  
11  11  11  11  11  11  11  11  11  11  11

在这里插入图片描述

5.1 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 1 - i; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

1  
2  2  
3  3  3  
4  4  4  4  
5  5  5  5  5  
6  6  6  6  6  6  
7  7  7  7  7  7  7  
8  8  8  8  8  8  8  8  
9  9  9  9  9  9  9  9  9  
10  10  10  10  10  10  10  10  10  10  
11  11  11  11  11  11  11  11  11  11  11

5.2 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

1  1  1  1  1  1  1  1  1  1  1  
2  2  2  2  2  2  2  2  2  2  
3  3  3  3  3  3  3  3  3  
4  4  4  4  4  4  4  4  
5  5  5  5  5  5  5  
6  6  6  6  6  6  
7  7  7  7  7  
8  8  8  8  
9  9  9  
10  10  
11

5.3 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= i; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

1  
2  2  
3  3  3  
4  4  4  4  
5  5  5  5  5  
6  6  6  6  6  6  
7  7  7  7  7  7  7  
8  8  8  8  8  8  8  8  
9  9  9  9  9  9  9  9  9  
10  10  10  10  10  10  10  10  10  10  
11  11  11  11  11  11  11  11  11  11  11

5.4 ：

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-i; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

1  1  1  1  1  1  1  1  1  1  1  
2  2  2  2  2  2  2  2  2  2  
3  3  3  3  3  3  3  3  3  
4  4  4  4  4  4  4  4  
5  5  5  5  5  5  5  
6  6  6  6  6  6  
7  7  7  7  7  
8  8  8  8  
9  9  9  
10  10  
11

6. 倒立序循环迭代N次：

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = 0; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

11  11  11  11  11  11  11  11  11  11  11  
10  10  10  10  10  10  10  10  10  10  10  
9  9  9  9  9  9  9  9  9  9  9  
8  8  8  8  8  8  8  8  8  8  8  
7  7  7  7  7  7  7  7  7  7  7  
6  6  6  6  6  6  6  6  6  6  6  
5  5  5  5  5  5  5  5  5  5  5  
4  4  4  4  4  4  4  4  4  4  4  
3  3  3  3  3  3  3  3  3  3  3  
2  2  2  2  2  2  2  2  2  2  2  
1  1  1  1  1  1  1  1  1  1  1

在这里插入图片描述

6.1 ：

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = i; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

11  
10  10  
9  9  9  
8  8  8  8  
7  7  7  7  7  
6  6  6  6  6  6  
5  5  5  5  5  5  5  
4  4  4  4  4  4  4  4  
3  3  3  3  3  3  3  3  3  
2  2  2  2  2  2  2  2  2  2  
1  1  1  1  1  1  1  1  1  1  1

6.2 ：

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = arr.length - 1 - i; j < arr.length; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

11  11  11  11  11  11  11  11  11  11  11  
10  10  10  10  10  10  10  10  10  10  
9  9  9  9  9  9  9  9  9  
8  8  8  8  8  8  8  8  
7  7  7  7  7  7  7  
6  6  6  6  6  6  
5  5  5  5  5  
4  4  4  4  
3  3  3  
2  2  
1

6.3 ：

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = 0; j < arr.length - i; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

11  
10  10  
9  9  9  
8  8  8  8  
7  7  7  7  7  
6  6  6  6  6  6  
5  5  5  5  5  5  5  
4  4  4  4  4  4  4  4  
3  3  3  3  3  3  3  3  3  
2  2  2  2  2  2  2  2  2  2  
1  1  1  1  1  1  1  1  1  1  1

6.4 ：

		for (int i = arr.length - 1; i >= 0; i--) {
			for (int j = 0; j <= i; j++) {
				System.out.print(arr[i] + "  ");
			}
			System.out.println();
		}

11  11  11  11  11  11  11  11  11  11  11  
10  10  10  10  10  10  10  10  10  10  
9  9  9  9  9  9  9  9  9  
8  8  8  8  8  8  8  8  
7  7  7  7  7  7  7  
6  6  6  6  6  6  
5  5  5  5  5  
4  4  4  4  
3  3  3  
2  2  
1
张紫娃
关注
数组的遍历
asdfghjop的博客
03-16 166
485. 最大连续 1 的个数 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。 示例 1： 输入：nums = [1,1,0,1,1,1] 输出：3 解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3. 示例 2: 输入：nums = [1,0,1,1,0,1] 输出：2 实现 class Solution(object): def findMaxConsecutiveOnes(self,nums): """ :type
数组系列——数组的遍历
troubles_killer的博客
11-30 496
leetcode数组——数组的遍历（485、495、414、628）
用循环数组实现队列
Kinglliam的专栏
05-04 4220
我们可以将队列当作一般的表用数组加以实现，但这样做的效果并不好。尽管我们可以用一个游标last来指示队尾，使得Enqueue运算可在O(1)时间内完成，但是在执行Dequeue时，为了删除队头元素，必须将数组中其他所有元素都向前移动一个位置。这样，当队列中有n个元素时，执行Dequeue就需要O(n)时间。为了提高运算的效率，我们用另一种方法来表达数组中各单元的位置关系。设想数组Q[1..Ma
数组循环
xiaomin_er的博客
11-13 496
1.forEach forEach 对数组直接进行循环，相当于直接for循环,没有返回值 let arr = [1,2,3,4,5,6]; arr.forEach((item,index,arr)=>{ console.log(item); console.log(index); console.log(arr); }) 2.map map,对数组每一项进行加工，加工完成之后返回1个新的数组 let arr2 = ['香蕉','苹果','雪梨']; let result = arr2.
数组的循环
Yang_lan1的博客
04-25 215
arr.forEach() 代替普通的for循环 可接收两个参数，（循环回调函数，this指向谁） let arr = ['apple','orange','bananer','tomato']; arr.forEach(function(val,index,arr){ console.log(val,index,arr);//值，索引，原数组 ...
数组之循环
oxygensunshine的博客
10-27 4595
数组之循环
遍历int、对象数组
weixin_37539225的博客
05-17 1192
int array[5] = [1,2,3,4,5] int *p = array // 指向数组首地址 &array[0] // 1 for(int i = 0; i<5; i++) { cout << array[i] << endl; } // 2 for (int i = 0; i<5; i++) { cout << *(p++) << endl; } // 3 #include<vector>.
thinkPHP中多维数组的遍历方法
10-22
总结来说，ThinkPHP中的多维数组遍历主要是通过`foreach`循环的嵌套实现。理解并熟练掌握这种遍历方式对于处理复杂数据结构至关重要，尤其是在构建复杂的Web应用时。结合模板语言，可以方便地在视图层展示和交互这些...
js中数组各种遍历方法的区别
踩坑之路
08-12 2466
js中数组各种遍历方法的区别 平时无论是使用数组还是对象，遍历都是一个很频繁的操作，在js中遍历数组或对象的方法有很多，在敲代码时有时会由于到底应该使用哪个，是不是使用哪个都一样？带着这样的疑惑，翻了一下文档，写了点代码测试一下，写篇博客记录一下。 一些老生常谈的区别 日常中常用的遍历方法大体有以下几种：for、forEach、for in、for of、map。 1、for循环用于循环执行一定次数的代码块，是一个js语句而不是方法，很通用的一种遍历方法，既可以用来循环数组也可以用来循环类数组的数据结构。
vue使用map代替Aarry数组循环遍历
01-08
原本的方法是使用for循环遍历该数组，变量 i 就是下标，问题在于，如果有多重for循环，就会导致性能大大下降，数据也容易出错 因此使用map，让数组（原本是list）变成一个map集合（key-value形式），把主键id当做key...
Java数组的遍历与求和知识点
08-27
一维数组遍历与求和： 在Java中，一维数组可以使用for循环来遍历和求和。下面是一个简单的示例： ```java public class OneArry{ public static void main(String[] args) { double[] num = {1.9, 2.9, 3.4, 3.5...
php两个多维数组组合遍历的实例
10-19
在处理这些数据时，有时我们需要遍历并组合两个或多个多维数组，以便进行进一步的计算、操作或者分析。本文将通过一个具体的实例来讲解如何在PHP中遍历和组合两个多维数组。 首先，我们要了解如何遍历一个多维数组...
循环数组
安逸风声
03-11 691
时间限制:10000ms单点时限:1000ms内存限制:256MB描述给定包含N个整数的数组A1, A2, ... AN，你可以选择任意一个Ai，将Ai旋转到数组第一项，即将数组变成：Ai, Ai+1, Ai+2, ... AN, A1, A2, ..., Ai-1  现在小Hi希望旋转之后的数组满足：对于任意K(1 ≤ i ≤ N)，前K项的和都是正数。  例如对于A=[3, -5, 2, -2...
JavaScript 数组find() 方法
qq_36742720的博客
05-07 6785
定义和用法 find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。 find() 方法为数组中的每个元素都调用一次函数执行： 当数组中的元素在测试条件时返回true时, find() 返回符合条件的元素，之后的值不会再调用执行函数。 如果没有符合条件的元素返回 undefined 注意:find() 对于空数组，函数是不会执行的。 注意:find() 并没有改变数组...
数组中循环常用方法
旺旺
10-24 2248
不废话，直接上正题。 forEach 让数组中的每一项都做一件事，如果不做特殊处理，一般情况下，不能中止或跳出 forEach 循环（使用break会报错，return false 也无效）。如果需要中途跳出循环，建议直接用for语句好了。 let arr = [1,2,3,4,5]; arr.forEach((item,index)=> { console.log(item); }) // 1,2,3,4,5 // for语句可以跳出循环 var arr = [1,2,3,4,5]; f
数组循环的几种方法
laoyaoshilaoyao的博客
10-24 2679
1、forEach let arr = [1,2,3,4,5] arr.forEach((item,index,array)=>{ console.log(item) // 12345 console.log(index) //01234 console.log(array) // [1,2,3,4,5] }) 2、map 需要return返回 返回一个新数组 let temp = arr.map((item,index,array)=>{ re
Java-网络
最新发布
2301_81543552的博客
09-14 455
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
二维不等长数组组合遍历与输出
在给定的代码片段中，我们看到的是一个用于遍历二维不等长数组并输出所有可能组合的实现。这个过程采用了类似于计时器的算法，通过递归的方式处理每个维度的元素。下面是详细的步骤和关键知识点： 1. **定义二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值