目录
 
一.使用数组下标遍历数组 
  
1.计算数组元素个数
2.通过下标遍历数组
 
二.使用数组首地址偏移遍历数组
三.使用指针遍历数组
四.猜你喜欢
 
 
 
零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门
 
 
一.使用数组下标遍历数组
 
数组中的每个元素都有一个序号，这个序号从 0 开始，称为下标 index，例如，a[0] 表示第 1 个元素，a[3] 表示第 4 个元素。数组是一个整体，它的内存是连续的，内存示意图：
 
 
1.计算数组元素个数
 
计算数组元素个数示例如下：
 
int arr[] = {1,2,3,4,5};
int len = sizeof(arr)/sizeof(arr[0]);  //正确的计算方式
int len = sizeof(arr);                 //错误的结算方式
 
2.通过下标遍历数组
 
/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    for (int i = 0; i < len; i++)
    {
        printf("根据下标索引值循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i,&arr[i],arr[i]);
    }
    system("pause");
}
/*
输出：
根据下标索引值循环：数组下标：0 对应的元素地址是： 1278408520 对应的元素的值是： 10
根据下标索引值循环：数组下标：1 对应的元素地址是： 1278408524 对应的元素的值是： 20
根据下标索引值循环：数组下标：2 对应的元素地址是： 1278408528 对应的元素的值是： 30
根据下标索引值循环：数组下标：3 对应的元素地址是： 1278408532 对应的元素的值是： 40
根据下标索引值循环：数组下标：4 对应的元素地址是： 1278408536 对应的元素的值是： 50
请按任意键继续. . .
*/
 
二.使用数组首地址偏移遍历数组
 
数组是一个整体，它的内存是连续的，那么我们可以直接通过首地址（数组名默认就是首地址）偏移来达到数组遍历的效果，内存示意图：
 
 
int arr[] = {1,2,3,4,5};
int value0 = *(arr);     //arr默认指向数组的首地址，获取数组第一个元素的值
int value1 = *(arr + 1); //数组首地址偏移 +1 ，获取数组第二个元素的值
int value2 = *(arr + 2); //数组首地址偏移 +2 ，获取数组第三个元素的值
int value3 = *(arr + 3); //数组首地址偏移 +3 ，获取数组第四个元素的值
 
当知道数组元素地址之后，可以直接通过 * 获取该地址对应的值，使用数组首地址偏移遍历数组，示例代码如下：
 
/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    for (int i = 0; i < len; i++)
    {
        printf("根据下标索引值循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i,arr+i,*(arr + i));
    }
    system("pause");
}
/*
输出：
根据下标索引值循环：数组下标：0 对应的元素地址是： 1619000120 对应的元素的值是： 10
根据下标索引值循环：数组下标：1 对应的元素地址是： 1619000124 对应的元素的值是： 20
根据下标索引值循环：数组下标：2 对应的元素地址是： 1619000128 对应的元素的值是： 30
根据下标索引值循环：数组下标：3 对应的元素地址是： 1619000132 对应的元素的值是： 40
根据下标索引值循环：数组下标：4 对应的元素地址是： 1619000136 对应的元素的值是： 50
请按任意键继续. . .
*/
 
三.使用指针遍历数组
 
使用指针遍历数组实际上也是通过地址偏移，和上面的数组首地址偏移遍历数组类似：
 
1.首先通过指针指向一个数组的首地址；
2.然后通过地址偏移，来获取对应地址的值，当知道数组元素地址之后，可以直接通过 * 获取该地址对应的值；
 
示例代码如下：
 
/************************************************************************/
//@Author:猿说编程
//@Blog(个人博客地址): www.codersrc.com
//@File:C语言教程 - C语言 使用指针遍历数组
//@Time:2021/06/18 08:00
//@Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
/************************************************************************/

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int arr[5] = { 10,20,30,40,50 };
    int* p = arr;  //定义一个空指针
    int len = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    //int value1 = *p++; // int value1 = arr[1];
    //int value2 = *p++; // int value2 = arr[2];
    //int value3 = *p++; // int value3 = arr[3];
    //int value4 = *p++; // int value4 = arr[4];
    for (int i = 0;i<len;i++)
    {
        printf("根据指针偏移循环：数组下标：%d 对应的元素地址是： %d 对应的元素的值是： %d\n", i, p, *p);
        p++; //地址偏移+1，等价偏移到下一个元素地址
    }
    system("pause");
}
/*
输出：
根据指针偏移循环：数组下标：0 对应的元素地址是： 663747608 对应的元素的值是： 10
根据指针偏移循环：数组下标：1 对应的元素地址是： 663747612 对应的元素的值是： 20
根据指针偏移循环：数组下标：2 对应的元素地址是： 663747616 对应的元素的值是： 30
根据指针偏移循环：数组下标：3 对应的元素地址是： 663747620 对应的元素的值是： 40
根据指针偏移循环：数组下标：4 对应的元素地址是： 663747624 对应的元素的值是： 50
请按任意键继续. . .
*/
 
四.猜你喜欢
 
安装 Visual Studio
安装 Visual Studio 插件 Visual Assist
Visual Studio 2008 卸载
Visual Studio 2003/2015 卸载
C 语言格式控制符/占位符
C 语言逻辑运算符
C 语言三目运算符
C 语言逗号表达式
C 语言 sizeof 和 strlen 函数区别
C 语言 strcpy 和 strcpy_s 函数区别
C 语言 memcpy 和 memcpy_s 区别
C 语言 数组定义和使用
C 语言 数组遍历
C 语言 数组排序 – 冒泡法排序
C 语言 数组排序 – 选择法排序
C 语言 数组排序 – 插入法排序
C 语言 数组排序 – 快速法排序
C 语言 数组下标越界
C 语言 数组内存溢出
C 语言 数组下标越界和内存溢出区别
C 语言 二维数组定义和使用
C 语言 二维数组行数和列数计算
C 语言 指针声明和定义
C 语言 指针 p++ / p–
C 语言 p++/§++/_(p++)/_p++
C 语言 使用指针遍历数组
 
未经允许不得转载：猿说编程 » C 语言 使用指针遍历数组

C++ 遍历数组常见的有三种方法
 
方法1 (有点类似java的foreach 循环)
 
#include <iostream>
using namespace std;
int main()
{

     // 一维数组
     int aar[] = {1, 2, 3, 4, 5, 6};
     for (int value :aar)
     {
      cout << value << endl;    
     };
};
 
遍历结果如下:
 
 
方法2
 
#include <iostream>
using namespace std;
int main()
{

     // 一维数组
     int aar[] = {1, 2, 3, 4, 5, 6};
     //先计算出数组的长度
     for (int i = 0; i < sizeof(aar) / sizeof(aar[0]); i++)
     {
          cout << aar[i] << endl;
     };
};
 
 遍历结果如下:
 
 
方法3
 
#include <iostream>
using namespace std;
int main()
{

     // 一维数组
     int aar[] = {1, 2, 3, 4, 5, 6};
     //使用指针
     for (int *p = aar; p <= &aar[sizeof(aar) / sizeof(aar[0]) - 1]; p++)
     {
          cout << *p << endl;
     };
};
 
 遍历结果如下
 
 

一、jQuery对象和伪数组
 
<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="UTF-8">
		<title>hhahah</title>
		<script src="jquery-1.12.4.min.js"></script>
		<script>
			$(function(){
				var $div = $("div");
				console.log($div);
				
				var arr = [1,3,5];
				console.log(arr);
			});
		</script>
	</head>
	<body>
		<div>div1</div>
		<div>div2</div>
		<div>div3</div>
	</body>
</html>
 
输出结果为：
 
 总结：
  1.什么是jQuery对象：
   jQuery对象是一个伪数组
  2.什么是伪数组：
     有0~length-1的属性，并且有length属性的对象
 

 二、jQuery - each()静态方法
 
<script>
	var arr = [1,3,5,7,9];
	var obj = {0:1,1:3,2:5,3:7,4:9};
	/**
	*1.利用原生JS的forEach方法遍历
	*第一个参数：遍历到的元素
	*第二个参数：当前遍历到的索引
	*注意：原生的forEach方法只能遍历数组，而不能遍历伪数组
	*/
	arr.forEach(function(value,index){
		console.log("原生forEach遍历数组:",index,value);
	});
	/**
	obj.forEach(function(value,index){
		console.log("原生forEach遍历伪数组:",index,value);
		//Uncaught TypeError: obj.forEach is not a function
	});
	*/

	/**
	* 2.利用jQuery的each静态方法遍历
	* 第一个参数：当前遍历到的索引
	* 第二个元素：遍历到的元素
	* 注意：jQuery的each方法可以遍历伪数组
	*/
	$.each(arr,function(index,value){
		console.log("jQuery-each方法遍历数组：",index,value);
	})
	$.each(obj,function(index,value){
		console.log("jQuery-each方法遍历伪数组：",index,value);
	})
</script>
 
输出结果如下：
 
 总结：
   1.原生的forEach方法只能遍历数组，而不能遍历伪数组
     2.jQuery的each方法可以遍历伪数组
 

 三、jQuery - map()静态方法
 
<script>
	var arr = [1,3,5,7,9];
	var obj = {0:1,1:3,2:5,3:7,4:9};
	/**
	*1.利用原生JS的map方法遍历 
	*第一个参数：遍历到的元素
	*第二个参数：当前遍历到的索引
	*第三个参数：当前被遍历的数组
	*注意：和原生的forEach方法一样，不能遍历伪数组
	*/
	arr.map(function(value,index,array){
		console.log("原生map遍历数组:",index,value,array);
	});
	/**
	obj.map(function(value,index,array){
		console.log("原生map遍历伪数组:",index,value,array);
		//Uncaught TypeError: obj.forEach is not a function
	});
	*/

	/**
	* 2.利用jQuery的each静态方法遍历
	* 第一个参数：要遍历的数组
	* 每遍历一个元素之后执行的回调函数
	* 回调函数的参数：
	* 	第一个参数：遍历到的元素
	* 	第二个元素：当前遍历到的索引
	* 注意：和jQuery的each方法一样可以遍历伪数组
	*/
	$.map(arr,function(value,index){
		console.log("jQuery-map方法遍历数组：",index,value);
	})
	$.map(obj,function(value,index){
		console.log("jQuery-map方法遍历伪数组：",index,value);
	})
</script>
 

 总结：
   1.原生的map方法只能遍历数组，而不能遍历伪数组
     2.jQuery的map方法可以遍历伪数组
 

 四、each()方法 和 map()方法的区别
 
<script>
	var obj = {0:1,1:3,2:5,3:7,4:9};

	/**
	* jQuery中的each静态方法和map静态方法的区别
	* each 静态方法默认的返回值就是，遍历谁就返回谁
	* map 静态方法的返回值是，一个空数组

	* each方法静态方法不支持在回调函数中对遍历的数组进行处理
	* map 静态方法可以在回调函数中通过return对遍历的数组进行操作，生成一个新的数组返回
	*/
	var $res1 = $.each(obj,function(index,value){
	});
	var $res2 = $.each(obj,function(index,value){
		return index + value;
	});
	var $res3 = $.map(obj,function(value,index){
	});
	var $res4 = $.map(obj,function(value,index){
		return value + index;
	});

	console.log("each方法返回值：",$res1);
	console.log("map方法返回值：",$res3);
	console.log("map方法操作后返回值：",$res2);
	console.log("map方法操作后返回值：",$res4);
</script>
 
输出结果为：
 
 总结：
  1、jQuery中的each静态方法和map静态方法的区别：
   1. each 静态方法默认的返回值就是，遍历谁就返回谁
     2. map 静态方法的返回值是，一个空数组
  2、是否支持在回调函数中对遍历的数组进行处理：
   1. each方法静态方法不支持在回调函数中对遍历的数组进行处理
     2. map 静态方法可以在回调函数中通过return对遍历的数组进行操作，生成一个新的数组返回
 

假设有一个5 x 4的二维矩阵，现需要按照顺时针方向将其螺旋遍历，返回数组中的元素：
 
 
若二维数组如上所述，则其顺时针螺旋遍历的结果为：1、2、3、4、5、10、15、20、19、18、17、16、11、6、7、8、9、14、13、12。
 
其实，二维数组的元素排列很像汉字的“回”。“回”字由一个大矩形包裹着一个小矩形，而二维数组也可以看成是外围的若干元素包裹着内部的元素，由外向内层层嵌套起来。
 
 
那么我们完全可以按照一定的顺序从外向内一层一层遍历，就等同于对二维数组进行螺旋遍历了。
 
我们可以把二维数组的每一层拆解成上下左右4条边，然后按照顺时针方向遍历上、右、下、左即可。
 
 
当然，需要注意的是在遍历同一层的4条边时，要避免重复遍历矩形的4个角，即需要注意外层的1、5、20、16和内层的7、9、14、12元素。还有，当二维数组的最内层只剩下一行或者一列的时候，最内层遍历不再是上下左右4条边。
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class test {
	
	public static List<Integer> spiralOrder(int[][] matrix) {
		
        List<Integer> list = new ArrayList<Integer>();
        //当二维数组是空或任何一个维度是0，直接返回
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return list;
        }
        
        //m是矩阵的行数
        int rows = matrix.length;
        //n是矩阵的列数
        int columns = matrix[0].length;
        //二维数组的层数，取决于行和列的较小值
        int size = (Math.min(rows, columns)+1)/2;
        
        //大循环，从外向内逐层遍历矩阵
        for(int i=0; i < size; i++) {
            //从左到右遍历“上边”
            for (int j = i; j < columns - i; j++) {
                list.add(matrix[i][j]);
            }
            //从上到下遍历“右边”
            for (int j = i + 1; j < rows - i; j++) {
                list.add(matrix[j][(columns - 1)-i]);
            }
            //从右到左遍历“下边”
            for (int j = i + 1; j < columns - i && (rows - 1) - i > i; j++) {
                list.add(matrix[(rows - 1)-i][(columns - 1) - j]);
            }
            //从下到上遍历“左边”
            for (int j = i + 1; j < rows - 1 - i && i < (columns - 1)-i; j++) {
                list.add(matrix[(rows - 1) - j][i]);
            }
        }
        return list;
    }

	public static void main(String[] args) {
		
		int[][] matrix = {
                { 1,  2,  3,  4,  5  },
                { 6,  7,  8,  9,  10 },
                { 11, 12, 13, 14, 15 },
                { 16, 17, 18, 19, 20 }
        };
        int[][] matrix2 = {
                { 1,  2,  3 },
                { 4,  5,  6 },
                { 7,  8,  9 },
                { 10, 11, 12 },
                { 13, 14, 15 }
        };
        List<Integer> List1 = spiralOrder(matrix);
        System.out.println(Arrays.toString(List1.toArray()));
        List<Integer> List2 = spiralOrder(matrix2);
        System.out.println(Arrays.toString(List2.toArray()));
		
	}
}
 
 
 
 
代码来源：https://mp.weixin.qq.com/s/FcCALo3tKWZpP2FE_16R5g