二维数组 订阅
二维数组本质上是以数组作为数组元素的数组,即“数组的数组”,类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵,行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i],对角矩阵:n阶方阵主对角线外都是零元素。 展开全文
二维数组本质上是以数组作为数组元素的数组,即“数组的数组”,类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵,行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i],对角矩阵:n阶方阵主对角线外都是零元素。
信息
适用领域范围
数组
表达式
a为3*4(3行4列)的数组
中文名
二维数组
实    质
float a[3][4],b[5][10]
二维数组定义
例如:float a[3][4],b[5][10];定义a为3*4(3行4列)的数组,b为5*10(5行10列)的数组。注意,不能写成float a[3,4],b[5,10];为便于理解特加入一个C语言程序及其运行结果:运行结果为(为便于观看,整理成表格):
收起全文
精华内容
参与话题
问答
  • 二维数组

    千次阅读 2020-05-13 17:12:45
    二维数组 ** 定义二维数组 int [] [] scores;//定义二维数组 scores = new int [3][5];//分配内存空间 或者 int [] [] scores = new int [3][5]; 注:int [] [] scores = new int [][]; 这样写是错误的必须给二维...

    **

    二维数组

    **
    定义二维数组
    int [] [] scores;//定义二维数组
    scores = new int [3][5];//分配内存空间
    或者
    int [] [] scores = new int [3][5];

    注:int [] [] scores = new int [][]; 这样写是错误的必须给二维数组分配内存空间 第一个括号是给二维数组分配内存空间的

    定义二维数组并赋值

    写法一:在这里插入图片描述
    写法二:
    在这里插入图片描述

    二维数组与内存
    int [][] score = new int[3][5];在这里插入图片描述

    冒泡排序
    每次比较相邻两数 小的交换在前面 每轮结束后最大的在交换到最后
    冒泡排序口诀(升序)
    N个数字来排队
    两两相比小靠前
    外层循环N-1
    内层循环N-1-i

    使用Arrays类的各种方法
    使用前加载 java.untin.Array包

    Array.sort(数组名) 对数组里面的元素进行升序排序
    注意:不能够对boolean类型的数组进行排序。

    Arrays.binarySearch() 查找某个元素在数组中的位置(数组一定是升序排列的数组)

    Arrays.toString() 将数组转为字符串

    Arrays.equals方法比较两个数组是否相等(这两个数组同一个类型的)
    如果两个数组相等返回值是true,否则返回值是false
    两个数组相等的含义: (1)长度要相等 (2)数组中每个位上的元素值要相等

    Arrays.fill(array,val) 把数组array所有元素都赋值为val

    Arrays.copyOf 将原数组中的元素拷贝到新的数组中。
    如果新的数组的长度大于原数组的长度,那么新数组中超出的元素的值是数组的默认值。
    如果新的数组的长度小于原数组的长度,那么新数组中只保留对应位置上的元素值。

    展开全文
  • 二维数组简介与使用

    千次阅读 2018-06-07 22:36:16
    前言本文将探讨一下关于二维数组在内存中的存储和二维数组在参数传递时的使用。一、二维数组在内存中的存储如果定义一个这样的二维数组int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};则其在内存中的表示可能...

    前言

    本文将探讨一下关于二维数组在内存中的存储和二维数组在参数传递时的使用。

    一、二维数组在内存中的存储

    如果定义一个这样的二维数组int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};则其在内存中的表示可能下面这样的。

    由上图可以看出,在内存中二维数组是按照行主序进行存储的,从内存的角度上看,二维数组本质就是一个一维数组。如果把二维数组的每一行看成一个整体,即看成一个数组中的一个元素,那么整个二维数组就是一个一维数组。而二维数组的名字代表二维数组第0行的首地址(注意它是代表一行元素的首地址,而不是第0行第0列元素的首地址,虽然是相等的,但不能这么理解,所以在没有强制转换的情况下,二维数据要么通过行指针进行参数传递,要么通过二维指针进行参数传递)

    二、二维数组在参数传递时的使用

    1、 可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以指定所有维数的大小,也可以省略第一维的大小说明,如:

         void Func(int array[3][10]);

         void Func(int array[][10]);

         但是不能把第二维或者更高维的大小省略,如下面的定义是不合法的:

          如 void Func(int array[3][]);

     因为从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(行主序),而并不区分行和列,如果在形参中不说明列数,则系统无法决定应为多少行,多少列,不能只指定一维而不指定第二维。

    2、将二维数组作为指针进行参数传递

    (1)直接作为行指针(数组指针)来传递参数(二维数组的名字代表二维数组第0行的首地址

    复制代码
     1 #include "stdafx.h"
     2 #include<iostream>
     3 using namespace std;
     4 
     5 void test(int (*a)[4],int m,int n)
     6 {
     7     cout<<*(*(a+m)+n);
     8 }
     9 
    10 int _tmain(int argc, _TCHAR* argv[])
    11 {
    12     int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};
    13     test(a,1,1);
    14     return 0;
    15 }
    复制代码

    上述程序中int (*a)[4],可以理解为二维数组的行指针(这个指针指向二维数组的行,而每一行最多有4列),a[n]表示二维数组的第n行,所以cout<<*(*(a+m)+n);先定位出a数组的第m行的位置,然后再求出第m行第n列的值

    (2)参数传递时将二维数组的强制转换为一维指针,然后按照内存中存储的方法计算二维数组对应成一维数组的下标

    复制代码
     1 #include "stdafx.h"
     2 #include<iostream>
     3 using namespace std;
     4 void test(int *a,int row,int column,int m,int n)
     5 {
     6     cout<<a[m*column+n];
     7 }
     8 
     9 int _tmain(int argc, _TCHAR* argv[])
    10 {
    11     int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};
    12     test((int*)a,3,4,1,1);
    13     return 0;
    14 }
    复制代码

    注意参数传递时将二维数组的强制转换为一维指针,如上述程序中的第12行

     

    注意:切不可将二维数组直接转换成二维指针作为形参传递,因为在这样子函数中不知道每一个一维元素含有多少个二维元素。

    如,下面这样写就是错误的:

    复制代码
    #include<iostream>
    using namespace std;
    void test(int **a,int m,int n)
    {
        cout<<*(*(a+m)+n);
    } 
    int main()
    {
         int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};
    
         test((int **)a,1,1);
         return 0;
     }
    复制代码

    展开全文
  • C/C++二维数组总结

    万次阅读 多人点赞 2018-12-16 16:01:29
    1、关于定义二维数组 先说在前面,一般的我们说的C/C++中的二维数组是定义在栈中的二维数组。比如定义了一个array[3][4],那就指的是定义了一个三行四列的矩阵形状的二维数组,如下图所示。这样的矩阵在内存中是以...

    1、关于定义二维数组

    先说在前面,一般的我们说的C/C++中的二维数组是定义在栈中的二维数组。比如定义了一个array[3][4],那就指的是定义了一个三行四列的矩阵形状的二维数组,如下图所示。这样的矩阵在内存中是以箭头右边的方式存放的,也就是说实际上我们定义的二维数组在内存中仍然像是一维数组那样连续存储的。可以想象为把一个矩阵一层层伸展铺平。

    因此可以使用如下方法定义二维数组:

    方法一: 直接确定二维数组的行和列数

    /* 可以使用下面的方法来初始化二维数组
     * 也就是直接将二维数组铺平,写成一维数组的形式
     */
    int array[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    
    /* 可以使用标准的二维数组的初始化方式
     */
    int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    方法二: 不用指明二维数组的行数,但要指明列数

    下面的一种写法本质上是定义了一个数组指针

    /* 经典的写法
     */
    int array[][4];
    
    /* 一种更帅的写法,本质上是定义了一个数组指针
     */
    int (*array)[4];

    方法三: 动态分配的方式,这种写法比较灵活,在定义的时候不需要指明二维矩阵的行数和列数

    /* 使用动态分配内存的形式,用malloc
     */
    int **array // array[M][N]
    array = (int **)malloc(M * sizeof(int *));
    for(int i = 0; i < M; i++) {
        array[i] = (int *)malloc(N * sizeof(int));
    }
    
    // 释放
    for(int i = 0; i < M; i++)
        free(array[i]);
    free(array);
    
    /* 使用动态分配内存的形式,用new
     */
    int **array // array[M][N]
    array = new int*[M];
    for(int i = 0; i < M; i++) {
        array[i] = new int[N];
    }
    
    // 释放
    for(int i = 0; i < M; i++) 
        delete [] array[i];
    delete [] array;
    
    

    不过按照这种形式实现的二维数组本质上已经不是我们之前说的传统的二维数组 了,采用此种方法定义的二维数组的结构如下图所示,这样的二维数组在堆上分配内存。也就是说这样实现的二维数组本质上已经是指针数组了。使用这样的方式分配二维数组空间之后,可以使用array[i][j]进行数组的读写操作没有问题,但是应该知道不同行的内存空间不一定连续。这是因为每一行的数组的内存都是使用malloc分配的,多次使用malloc分配的内存空间并不一定是连续的,这与在栈上分配的二维矩阵有着根本的不同,比如同样的对于顶底的二维数组array[3][4],不能再使用array[0][4]来访问array[1][0]了,这样会导致地址越界,就是因为地址不一定连续了。

     2 、二维数组的传参写法

    使用二维数组作为参数,可以有以下几种写法。

    1 使用动态分配内存的方式申请空间,可以使用**传递参数

    希望在使用二维数组的时候保持良好的编程习惯,使用哪种方法定义的就使用哪种方式传参,这样对于保持良好的编码习惯有好处,对于别人阅读你的代码也有好处。

    #include <iostream>
    using namespace std;
    
    int func1(int **arr) {
    	cout << arr[0][0];
    	arr[0][2] = 20;
    	return 0;
    }
    
    int main()
    {
    	int **array
    	int row = 3;
    	int col = 4;
    	array = (int **)malloc(row * sizeof(int *));
    	for (int i = 0; i < row; i++) {
    		array[i] = (int *)malloc(col * sizeof(int));
    	}
    	memset(*array, 0, sizeof(int)*row*col);
    
    	array[0][1] = 100;
    	func1(array);
    	cout << array[0][2];
    	return 0;
    }

    2 使用二维数组的传统定义方法传递参数

    如果把数组名作为函数的参数的话,在编译的时候这个数组参数会自动退化为指针,因此以下两种写法虽然不同,但在编译之后是一样的,数组会退化成数组指针。

    #include <iostream>
    using namespace std;
    
    /*
     * 以下两种写法本质上是一样的
     */
    int func1(int (*arr)[4]) {
    	cout << arr[0][0] << endl;
    	arr[0][2] = 20;
    	return 0;
    }
    
    int func2(int arr[][4]) {
    	cout << arr[0][0] << endl;
    	arr[0][2] = 20;
    	return 0;
    }
    
    int main()
    {
    	int array[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    
    	array[0][1] = 100;
    	func1(array);
    	cout << array[0][2] << endl;
    	return 0;
    }

    正是因为这个问题,在定义如下类似求数组大小的函数的时候必须将数组引用传递!否则数组会退化为一个指针,无法正确的使用sizeof运算符求出数组a所占内存空间大小。

    template<class T>
    int GetArrayLen(T& a)
    {
        return sizeof(a)/sizeof(a[0]);
    }

     

    展开全文
  • 数据结构---二维数组

    千次阅读 2018-08-24 09:49:52
    1、二维数组 定义:二维数组可以看做是特殊的一维数组,可以用于存储一维数组 二维数组定义方式:  1)数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];  例:int[][] ...

    1、二维数组

    定义:二维数组可以看做是特殊的一维数组,可以用于存储一维数组

    二维数组定义方式:

                 1)数组类型[][]   数组名 = new   数组类型[一维数组的个数][每一个一维数组中元素的个数];

                          例:int[][]   arr=new   int[3][4];

                                 int[][]    arr=new   int[][]{{1,2,3,4},{5,6,7,8},{2,3,4,5}};//数组的初始化

    二维数组的长度表示:

                  a.length表示一维数组的个数,即二维数组的行数

                  a[0].length表示每个一维数组的个数,即二维数组第一行的列数

    Arrays的用法:

                  遍历: toString()    将数组的元素以字符串的形式返回

                  排序: sort()        将数组按照升序排列

                  查找: binarySearch()在指定数组中查找指定元素,返回元素的索引,如果没有找到返回(-插入点-1) 注意:使用查找的功能的时候,数组一定要先排序。

     

    二维数组内存空间:

     

    二维数组内存空间分配如图所示:int   cars[][]、int   names[][]、int   computers[][]    

    Java数组及其内存分配

    展开全文
  • 正确定义二维数组

    千次阅读 2019-06-24 16:23:17
    二维数组进行正确初始化 二维数组必须指定列的数量,行的数量可以不定义即可以省略第一维的定义,但不能省略第二维的定义 1.分行进行初始化 int a[2][3] = {{1,2,3},{4,5,6}}; 在{}内部再用{}把各行分分开,第0行...
  • 二维数组初始化规则

    万次阅读 多人点赞 2018-03-27 14:24:16
    二维数组初始化的形式为: 数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }; 在{ }中给出各数组元素的初值,各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。 有如下几种初始化方式: ...
  • 维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] data=new int [5] :声明并开辟一个长度为5的数组 数组通过下标索引来获取元素,下标默认从0开始。数组下标...
  • 1 static int a[10]={0,1,2,3,4,5,6,7,8,9};...经过上面的定义和初始化后,a[0]=0,a[1]=1,…,a[9]=9。 (2)初始化时可以只对一部分元素赋初值。例如: 1 static int a[10]=
  • memset函数为二维数组初始化

    万次阅读 2018-05-28 17:38:13
    1int* a; a = new int[10];sizeof(a) 只会返回出来指针的大小,所以我们只能自己计算这个数组的长度,这里应当是sizeof(int) * 10,...//将a数组初始化为02 int **p;//开一个n*m的数组 p = new int*[n]; for (int i = ...
  • 二维数组初始化

    千次阅读 2019-09-26 10:32:19
    (1)二维数组初始化 int a[ ][4]={1,2,3,4,5,6,7,8,9,10,11,12} ; int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12} ; int a[3][4]={ {1,2,3},{4,5,6},{7,8,9},{10,11,12} } ; 这三者赋值方式等价; 这个赋值方法是...
  • ![图片说明](https://img-ask.csdn.net/upload/201711/06/1509937541_702321.png) ``` #include #include int main() { int i; char s[2][5]={"12345","12345"}; for(i=0;i;i++) { printf("%s\n",s[i]);...
  • C++二维数组初始化的形式

    万次阅读 2019-08-26 09:36:23
    数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }; 在{ }中给出各数组元素的初值,各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。 有如下几种初始化方式: ⑴ 分行进行初始化 int a[2][3]=...
  • java二维数组初始化(动态,静态)

    千次阅读 2018-03-13 09:03:04
    int[][] a=new int[][]{{1,2},{3,4},{5,6,7,8,9},{}}; System.out.println(a....//4,表示数组的行数 System.out.println(a[0].length);//2,表示对应行的长度 System.out.println(a[1].length);//2 System...
  • java二维数组初始化的三种方式

    千次阅读 2019-07-30 17:16:10
    下面主要介绍下二位数组初始化的三种方式 1、定义数组的同时使用大括号直接赋值,适合数组元素已知的情况 2、定义二维数组的大小,然后分别赋值 3、数组第二维的长度可变化 //第一种方式:定义的同时大括号...
  • 下面简单了解一下二维数组,包括数组的声明和初始化。 创建二维数组 在 Java 中二维数组被看作数组的数组,即二维数组为一个特殊的一维数组,其每个元素又是一个一维数组。Java 并不直接支持二维数组,...
  • memset函数与二维数组初始化的问题

    万次阅读 2016-03-10 19:27:29
    今天在编写Levenshtein distance距离函数时用到二维数组,用memset对其初始化时发生了问题,直接代码: int** m = NULL; int i = 0,j = 0; m = (int**)malloc(row * sizeof(int)); for (i = 0;i ; i++) { m...
  • Python 二维数组初始化

    千次阅读 2015-11-24 17:59:23
    Python二维数组初始化常犯的错误创建一个二维数组: test_list = [[]] * 4 然后,向第一个列表中插入数值: test_list[0].append(1) print test_list 此时会出现: [[1],[1],[1],[1]] 这说明这种创建数组的...
  • vector二维数组初始化

    千次阅读 2018-12-05 18:28:37
    int main() { vector<vector<int> >num = { {1,1,1,0,1,1},{1,0,1,1,1,1},{1,1,1,0,0,1},{1,0,1,0,0,1},{1,1,1,1,1,1} }; ...
  • golang二维数组初始化

    千次阅读 2020-10-21 21:42:00
    golang二维数组初始化来看一下,有点特别 func main() { x := 2 y := 4 table := make([][]int, x) for i := range table { table[i] = make([]int, y) } }
  • java二维数组初始化

    万次阅读 2019-02-22 16:35:59
    1.int [][] a=new int[][]{{1,2,3},{2,3}}; 2.int [][] a=new int[4][4]; 3.int [][]a=new int[3][];  a[2]=new int[3];

空空如也

1 2 3 4 5 ... 20
收藏数 390,703
精华内容 156,281
关键字:

二维数组