多维数组(Multi-dimensional Array)

最新推荐文章于 2023-02-22 12:34:43 发布
最新推荐文章于 2023-02-22 12:34:43 发布
阅读量6.3k 收藏 8
点赞数 2
分类专栏： C++数据结构 文章标签： 数据结构 数组 多维数组的逻辑结构 多维数组的存储表示 多维数组的实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/51695111
版权

多维数组(Multi-dimensional Array)

1. 多维数组的概念

  • 多维数组是指二维及以上的数组。
  • 数组是下标(index)和值(value)组成的序对的集合。
  • 在数组中，每个有定义的下标都与一个值对应，这个值称作数组元素。
    (1)二维数组：”数组元素为一维数组”的一维数组。
    (2)三维数组：”数组元素为二维数组”的一维数组。
    (3)四维数组：”数组元素为三维数组”的一维数组，如此类推。
  • 静态数组和动态数组的区别：
    (1)静态数组：必须在定义它时指定其大小和类型，在程序运行过程中其结构不能改变，在程序执行结束时自动撤销。
    (2)动态数组：在程序运行过程中才为它分配存储空间。

2. n维数组的逻辑结构

2.1 一维数组的逻辑结构
  • 一维数组中，每一个元素在数组中的位置由下标唯一确定。
  • 一维数组中，除第一个元素外，其他元素有且仅有一个直接前驱，第一个元素没有前驱，除最后一个元素外，其他元素有且仅有一个直接后继，最后一个元素没有后继。
  • 注：一维数组是指具有相同数据类型的n(n≥0，n为数组长度或数组大小，若n=0就是空数组)个元素的有限序列，因此，一维数组称为向量。
2.2 二维数组的逻辑结构
  • 二维数组(如a[n][m])中，每一个元素(a[i][j](0≤i≤n-1， 0≤j≤m-1))，同时处于第i个行向量和第j个列向量之中。
  • 二维数组(如a[n][m])中，每一个元素(a[i][j](0≤i≤n-1， 0≤j≤m-1))，在行的方向和列的方向各有一个直接前驱和一个直接后继，分别是a[i][j-1]，a[i-1][j]和a[i][j+1]，a[i+1][j]。
  • 二维数组(如a[n][m])中，每一个元素(a[i][j](0≤i≤n-1， 0≤j≤m-1))，在数组中的位置需由下标的二元组[i][j]唯一确定。
  • 二维数组(也称矩阵)，矩阵第0列的元素在行的方向没有前驱，第m-1列的元素在行的方向没有后继，第0行的元素在列的方向没有前驱，第n-1行的元素在列的方向没有后继。
  • 注：二维数组称为矩阵，它可以看作是由n个行向量和m个列向量所组成的向量，即二维数组a[n][m]是一个矩阵，总共有n*m个数组元素。因此，二维数组可以看作最简单的非线性结构。
2.3 三维数组的逻辑结构
  • 三维数组(如a[ m1 ][ m2 ][ m3 ])中，每一个元素(a[i][j][k](0≤i≤ m1 -1， 0≤j≤ m2 -1， 0≤k≤ m3 -1))，同时处于3个向量之中。
  • 三维数组(如a[ m1 ][ m2 ][ m3 ])中，每一个元素(a[i][j][k](0≤i≤ m1 -1， 0≤j≤ m2 -1， 0≤k≤ m3 -1))，最多有3个直接前驱和3个直接后继。
  • 三维数组(如a[ m1 ][ m2 ][ m3 ])中，每一个元素(a[i][j][k](0≤i≤ m1 -1， 0≤j≤ m2 -1， 0≤k≤ m3 -1))，在数组中的位置需由下标的三元组[i][j][k]唯一确定。
  • 注：如此类推，在一个n维数组(如a[ m1 ][ m2 ]……[ mn ])中，总共有 m1 * m2 * …… * mn 个数组元素。每一个数组元素(a[ i1 ][ i2 ]……[ in ](0≤ i1 ≤ m1 -1， 0≤ i2 ≤ m2 -1， ……，0≤ in ≤ mn -1))，同时处于n个向量之中，其位置由下标的n元组[ i1 ][ i2 ]……[ in ]唯一确定。

3. n维数组的存储表示

注：多维数组实际上是用一维数组实现的，那么可以利用一维数组的存储方式来表示多维数组。在实现数组的存储时，通常是按各个数组元素的排列顺序，顺次存放在一个连续的存储区域中，这样得到一个所有数组元素的线性序列。

3.1 一维数组的存储表示
  • 注：一维数组a[n]，数组第一个元素的存储起始地址为a，每个数组元素的存储大小为len。
  • 数组元素的存储地址的递推公式：
    这里写图片描述

  • 数组元素的存储地址表：

    数组下标 index(i)[0][1][2]……[n-1]
    存储地址 LOC(i)aa+1* lena+2* len……a+(n-1)* len
3.2 二维数组的存储表示
  • 注：按行优先的顺序存储。二维数组数组a[n][m]，数组第一个元素的存储起始地址为a，每个数组元素的存储大小为len。
  • 数组元素的存储地址的递推公式：
    这里写图片描述

  • 数组元素的存储地址表：

    数组下标 index(i,j)[0][0][0][1][0][2]……[n-1][m-1]
    存储地址 LOC(i,j)aa+(0* m+1)* lena+(0* m+2)* len……a+((n-1)* m+(m-1))* len
3.3 三维数组的存储表示
  • 注：按行优先的顺序存储。三维数组数组a[ m1 ][ m2 ][ m3 ]，数组第一个元素的存储起始地址为a，每个数组元素的存储大小为len。
  • 数组元素的存储地址的递推公式：
    这里写图片描述

  • 数组元素的存储地址表：

    数组下标 index(i,j,k)[0][0][0][0][0][1][0][0][2]……[ m1 -1][ m2 -1][ m3 -1]
    存储地址 LOC(i,j,k)aa+(0* m2 * m3 +0* m3 +1)* lena+(0* m2 * m3 +0* m3 +2)* len……a+(( m1 -1)* m2 * m3 +( m2 -1)* m3 +( m3 -1))* len

4. n维数组的实现

  • 相关转换实现文件：Transform.h

    
#include <iostream>


#include <sstream>


#include <string>


using namespace std;

struct Item;

string hex_to_string(Item* item)
{
    string str;
    stringstream sstr;
    sstr<<item;
    sstr>>str;
    return str;
}

int hex_to_decimal(const char* szHex)
{
    int decimal = 0;
    for (int i=0; szHex[i] != '\0'; i++)
    {
        if ((szHex[i] >= '0') && (szHex[i] <= '9'))
        {
            decimal = decimal*16 + szHex[i] - '0';
        }
        if ((szHex[i] >= 'a') && (szHex[i] <= 'f'))
        {
            decimal = decimal*16 + szHex[i] - 'a' + 10;
        }
        if ((szHex[i] >= 'A') && (szHex[i] <= 'F'))
        {
            decimal = decimal*16 + szHex[i] - 'A' + 10;
        }
    } 
    return decimal;
}

void decimal_to_hex(string& szHex, int szDecimal)
{
    if(szDecimal == 0)      
    {
        return; 
    }
    decimal_to_hex(szHex, szDecimal/16);
    int m = szDecimal % 16;  
    szHex += char(m + (m< 10 ? '0' : 'A' - 10));
}
4.1 一维数组的实现

  • 静态分配存储空间，文件：OneDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '1';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{
    int x;
    char dimension;
};

int main()
{
    const int n = 6;
    Item OneDimensionalArray[n];

    for (int i = 0; i < n; i++)
    {
        Item item;
        item.x = i; item.dimension = dimension;
        OneDimensionalArray[i] = item;
    }

    Item *a = OneDimensionalArray;
    int len = sizeof(Item);
    cout << "* 静态分配存储空间，一维数组OneDimensionalArray[" << n << "]。" << endl;
    cout << "\n* 数组第一个元素的存储起始地址：a = &OneDimensionalArray[0] = OneDimensionalArray = " << a << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "item[" << i << "]=" << OneDimensionalArray[i].x << ", "
             << "LOC(" << i << ") = a+i*len = " << hex_to_decimal(hex_to_string(a).c_str()) + i * len
             << " = &OneDimensionalArray[" << i << "] = " << &OneDimensionalArray[i] << endl;
    }

    system("pause");
    return 0;
}

  • 动态分配存储空间，文件：OneDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '1';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{   
    int x;
    char dimension;
};

int main()
{
    int n = 0;
    cout << "$ 请输入一维数组的元素个数，n = ";
    cin >> n;
    Item *OneDimensionalArray = new Item[n];

    for (int i = 0; i < n; i++)
    {
        Item item;  
        item.x = i; item.dimension = dimension;
        OneDimensionalArray[i] = item;
    }

    Item *a = OneDimensionalArray;
    int len = sizeof(Item);
    cout << "\n* 动态分配存储空间，一维数组OneDimensionalArray[" << n << "]。" << endl;
    cout << "\n* 数组第一个元素的存储起始地址：a = &OneDimensionalArray[0] = OneDimensionalArray = " << a << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "item[" << i << "]=" << OneDimensionalArray[i].x << ", "
             << "LOC(" << i << ") = a+i*len = " << hex_to_decimal(hex_to_string(a).c_str()) + i * len
             << " = &OneDimensionalArray[" << i << "] = " << &OneDimensionalArray[i] << endl;
    }

    delete[] OneDimensionalArray;
    OneDimensionalArray = NULL;

    system("pause");
    return 0;
}
4.2 二维数组的实现

  • 静态分配存储空间，文件：TwoDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '2';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{   
    int x;
    int y;
    char d;
};

int main()
{
    const int n = 2;
    const int m = 3;
    Item TwoDimensionalArray[n][m];

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            Item item;  
            item.x = i; item.y = j; item.d = dimension;
            TwoDimensionalArray[i][j] = item;
        }
    }

    Item *a = TwoDimensionalArray[0];
    int len = sizeof(Item);
    cout << "* 静态分配存储空间，二维数组TwoDimensionalArray[" << n << "][" << m << "]。" << endl;
    cout << "\n* 数组第一个元素的存储起始地址：a = &TwoDimensionalArray[0][0] = TwoDimensionalArray[0] = " << a << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cout << "item[" << i << "," << j << "]=(" << TwoDimensionalArray[i][j].x << "," << TwoDimensionalArray[i][j].y << "), "
                 << "LOC(" << i << "," << j << ") = a+(i*m+j)*len = " << hex_to_decimal(hex_to_string(a).c_str()) + (i * m + j) * len
                 << " = &TwoDimensionalArray[" << i << "," << j << "] = " << &TwoDimensionalArray[i][j] << endl;
        }
        cout << endl;
    }

    system("pause");
    return 0;
}

  • 动态分配存储空间，文件：TwoDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '2';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{   
    int x;
    int y;
    char d;
};

int main()
{
    int n = 0;
    int m = 0;
    cout << "$ 请输入二维数组行的元素个数，n = ";
    cin >> n;
    cout << "$ 请输入二维数组列的元素个数，m = ";
    cin >> m;
    Item **TwoDimensionalArray = new Item*[m];

    for (int i = 0; i < n; i++)
    {
        TwoDimensionalArray[i] = new Item[m];
        for (int j = 0; j < m; j++)
        {
            Item item;  
            item.x = i; item.y = j; item.d = dimension;
            TwoDimensionalArray[i][j] = item;
        }
    }

    Item *a = NULL;
    int len = sizeof(Item);
    cout << "\n* 动态分配存储空间，二维数组TwoDimensionalArray[" << n << "][" << m << "]。" << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < n; i++)
    {
        a = TwoDimensionalArray[i];
        cout << "\n* 数组第" << i << "行第一个元素的存储起始地址：a = &TwoDimensionalArray[" << i << "][0] = TwoDimensionalArray[" << i << "] = " << a << endl;
        for (int j = 0; j < m; j++)
        {
            cout << "item[" << i << "," << j << "]=(" << TwoDimensionalArray[i][j].x << "," << TwoDimensionalArray[i][j].y << "), "
                 << "LOC(" << i << "," << j << ") = a+j*len = " << hex_to_decimal(hex_to_string(a).c_str()) + j * len
                 << " = &TwoDimensionalArray[" << i << "," << j << "] = " << &TwoDimensionalArray[i][j] << endl;
        }
        cout << endl;
    }

    for (int i = 0; i < n; i++)
    {
        delete[] TwoDimensionalArray[i];
    }
    delete[] TwoDimensionalArray;
    TwoDimensionalArray = NULL;

    system("pause");
    return 0;
}
4.3 三维数组的实现

  • 静态分配存储空间，文件：ThreeDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '3';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{   
    int x;
    int y;
    int z;
    char d;
};

int main()
{
    const int m1 = 1;
    const int m2 = 2;
    const int m3 = 3;
    Item ThreeDimensionalArray[m1][m2][m3];

    for (int i = 0; i < m1; i++)
    {
        for (int j = 0; j < m2; j++)
        {
            for (int k = 0; k < m3; k++)
            {
                Item item;  
                item.x = i; item.y = j; item.z = k; item.d = dimension;
                ThreeDimensionalArray[i][j][k] = item;
            }
        }
    }

    Item *a = ThreeDimensionalArray[0][0];
    int len = sizeof(Item);
    cout << "* 静态分配存储空间，三维数组ThreeDimensionalArray[" << m1 << "][" << m2 << "][" << m3 <<"]" << endl;
    cout << "\n* 数组第一个元素的存储起始地址：a = &ThreeDimensionalArray[0][0][0] = ThreeDimensionalArray[0][0] = " << a << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < m1; i++)
    {
        for (int j = 0; j < m2; j++)
        {
            for (int k = 0; k < m3; k++)
            {
                cout << "item[" << i << "," << j  << "," << k << "]=(" << ThreeDimensionalArray[i][j][k].x << "," << ThreeDimensionalArray[i][j][k].y << "," << ThreeDimensionalArray[i][j][k].z << "), "
                     << "LOC(" << i << "," << j  << "," << k  << ") = a+(i*m2*m3+j*m3+k)*len = " << hex_to_decimal(hex_to_string(a).c_str()) + (i * m2 * m3 + j * m3 + k) * len
                     << " = &ThreeDimensionalArray[" << i << "," << j << "," << k << "] = " << &ThreeDimensionalArray[i][j][k] << endl;
            }
            cout << endl;
        }
        cout << endl;
    }

    system("pause");
    return 0;
}

  • 动态分配存储空间，文件：ThreeDimensionalArray.cpp

    
#include "Transform.h"


const char dimension = '3';

//使用预编译指令#pragma pack(value)来告诉编译器，使用指定的对齐值来取代缺省的。
//目的是让struct不字节对齐(默认是字节对齐的)。

#pragma pack(1)

struct Item
{   
    int x;
    int y;
    int z;
    char d;
};

int main()
{
    int m1 = 0;
    int m2 = 0;
    int m3 = 0;
    cout << "$ 请输入三维数组m1方向的元素个数，m1 = ";
    cin >> m1;
    cout << "$ 请输入三维数组m2方向的元素个数，m2 = ";
    cin >> m2;
    cout << "$ 请输入三维数组m3方向的元素个数，m3 = ";
    cin >> m3;
    Item ***ThreeDimensionalArray = new Item**[m3];

    for (int i = 0; i < m1; i++)
    {
        ThreeDimensionalArray[i] = new Item*[m3];
        for (int j = 0; j < m2; j++)
        {
            ThreeDimensionalArray[i][j] = new Item[m3];
            for (int k = 0; k < m3; k++)
            {
                Item item;  
                item.x = i; item.y = j; item.z = k; item.d = dimension;
                ThreeDimensionalArray[i][j][k] = item;
            }
        }
    }

    Item *a = NULL;
    int len = sizeof(Item);
    cout << "\n* 动态分配存储空间，三维数组ThreeDimensionalArray[" << m1 << "][" << m2 << "][" << m3 << "]。" << endl;
    cout << "\n* 每个数组元素的存储大小：len = sizeof(Item) = " << len << endl;
    cout << "\n$ 输出数组中所有元素的值及其存放地址==>" << endl;
    for (int i = 0; i < m1; i++)
    {   
        for (int j = 0; j < m2; j++)
        {
            a = ThreeDimensionalArray[i][j];
            cout << "\n* 数组第" << i << "行," << "第" << j << "列第一个元素的存储起始地址：a = &ThreeDimensionalArray[" << i << "][" << j << "][0] = ThreeDimensionalArray[" << i << "][" << j << "] = " << a << endl;
            for (int k = 0; k < m3; k++)
            {
                cout << "item[" << i << "," << j  << "," << k << "]=(" << ThreeDimensionalArray[i][j][k].x << "," << ThreeDimensionalArray[i][j][k].y << "," << ThreeDimensionalArray[i][j][k].z << "), "
                     << "LOC(" << i << "," << j << "," << k << ") = a+k*len = " << hex_to_decimal(hex_to_string(a).c_str()) + k * len
                     << " = &ThreeDimensionalArray[" << i << "," << j << "," << k << "] = " << &ThreeDimensionalArray[i][j][k] << endl;
            }
            cout << endl;
        }
        cout << endl;
    }

    for (int i = 0; i < m1; i++)
    {
        for (int j = 0; j < m2; j++)
        {
            delete[] ThreeDimensionalArray[i][j];
        }
    }
    for (int i = 0; i < m1; i++)
    {
        delete[] ThreeDimensionalArray[i];
    }
    delete[] ThreeDimensionalArray;
    ThreeDimensionalArray = NULL;

    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第四章
[2] 百度搜索关键字：多维数组

Cainv89
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多维数组的运算
01-06
一、多维数组 简单来讲，多维数组就是“数字的集合”，数字排成一列的集合、排成长方形的集合、排成三维状或者（更加一般化）N 维状的集合都称为多维数组。 如上所述，数组的维数可以通过 np.dim()函数获得。此外，数组的形状可以通过实例变量shape 获得。在上面的例子中，A 是一维数组，由 4 个元素组成。这里的 A.shape 的结果是个元组。这是因为一维数组的情况下也要返回和多维数组的情况下一致的结果。例如：二维数组时返回的元组（4,3），三维数组返回的元组（4,3,2），因此一维数组时也同样以元组的形式返回结果。下面声称二维数组。 这里生成一个 3×2 的数组 B。3×2 的数组表示
什么是多维数组？怎样定义多维数组？
Blue92120的博客
11-02 2140
上面的代码相当于定义了一个3*4的二维数组，这个二维数组的长度为3，我们可以将它看成3个int[]类型的一维数组，每个一维数组中的元素又是一个长度为4的一维数组。在程序中，比较常见的多维数组是二维数组，接下来本节将针对二维数组进行详细讲解，我们以统计学校各个班级学生的考试成绩，来实现。接下来通过一个统计公司三个销售小组中每个小组的总销售额，以及整个公司销售额的案例来熟悉二维数组的使用，如下所示。二维数组可以被看作是特殊的一维数组，其定义有很多方式，接下来针对几种常见的方式进行详细讲解，具体如下。
C 语言 —— 多维数组
柚咖小窝
09-26 4869
多维数组其实就是二维数组的继续延申，而且在正常项目中，常用的多维数组就是二维数组了，因此下面我们重点介绍一下二维数组的定义、初始化以及使用。 1. 什么是二维数组？ 我们之前介绍的数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。 在实际问题中有很多量是二维的或多维的，因此 C 语言允许构造多维数组。多维数组元素有多个下标，以标识它在数组中的位置，所以也称为多下标变量。 二维数组就是有两个下标的数组，是常用的多维数组，更高维的数组其实使用的并不多。 2. 二维数组的定义 二维数组定义的一般形式：
VS-Cube: Analyzing Variations of Multi-dimensional Patterns over Data Streams
02-08
In many applications, patterns over time-varied data streams usually imply high domain value. The variations of patterns can often be measured from their internal structures. Traditional methods usually take each pattern as a whole to analyze data stream variations; however, few works have achieved a widely applicable resolution. This paper considers the feature of sub parts for data stream patterns and studies their variations and relationships from the perspective of multiple dimensions,<br>
multi-dimensional classification via sparse label encoding.pdf
09-29
【ICML2021】基于稀疏标签编码的多维分类 在多维分类中，输出空间中存在多个类变量，每个类变量对应一个异构类空间。由于类空间的异质性，在从MDC示例中学习时，考虑类变量之间的依赖关系非常具有挑战性。本文提出了一种新的多目标预测方法，即SLEM方法，它在编码的标签空间中学习预测模型，而不是在异构的标签空间中学习预测模型。具体来说，SLEM在编码-训练-解码框架中工作。在编码阶段，通过成对分组、一次热转换和稀疏线性编码三种级联操作，将每个类向量映射为实值向量。在训练阶段，在编码标签空间内学习多输出回归模型。在解码阶段，通过对学习的多输出回归模型的输出进行正交匹配追踪，得到预测的类向量。实验结果清楚地验证了SLEM相对于最先进的MDC方法的优越性。
多维数组
q20011的博客
08-27 5416
1.多维数组概述 数组是一个线性数据结构，用于储存一组相同数据类型的数据（长度一经定义就不能改了） 2.多维数组定义 3.多维数组的遍历 4.多维数组的使用 5.算法概述 6.排序算法 冒泡排序 选择排序 插入排序 7.引用数据类型 ...
c基础知识：多维数组详解
weixin_50941083的博客
10-29 5485
如果某个数组的维数不止一个，就可以被称为多维数组，以下让我们具体看一下多维数组的相关知识。
C语言进阶（五）—— 多维数组
此心光明事上练的博客
02-22 1041
源代码的可读性几乎总是比程序的运行时效率更为重要只要有可能，函数的指针形参都应该声明为const在多维数组的初始值列表中使用完整的多层花括号提高可读性在绝大多数表达式中，数组名的值是指向数组第1个元素的指针。这个规则只有两个例外，sizeof和对数组名&。指针和数组并不相等。当我们声明一个数组的时候，同时也分配了内存。但是声明指针的时候，只分配容纳指针本身的空间。当数组名作为函数参数时，实际传递给函数的是一个指向数组第1个元素的指针。
多维数组的定义
千锋教育
02-13 898
一. 多维数组1. 概念多维数组可以看成是数组的数组。比如二维数组就是一个特殊的一维数组，它的每个元素都是一个一维数组。其他多维数组的概念，大家可以参照二维数组以此类推。2. 分类多维数组可以分为：●二维数组；● 三维数组；● 其他数组；其实我们在开发时，真正常用的数组也就是一维数组和二维数组，更多维度的数组很少使用。所以接下来在本篇文章中，主要是给大家讲解二维数组相关的内容。二. 多维数组理论上，在Java中我们可以定义出任意维度的数组。
Multi-dimensional niche construction and
12-10
Multi-dimensional niche construction and diversification in trait-based Lotka-Volterra
Solving High-Dimensional Multi-Objective Optimization Problems with Low Effective Dimensions
02-06
Multi-objective (MO) optimization problems require simultaneously optimizing two or more objective functions. An MO algorithm needs to find solutions that reach different optimal balances of the objective functions, i.e., optimal Pareto front, therefore, high dimensionality of the solution space can hurt MO optimization much severer than single-objective optimization, which was little addressed in previous studies. This paper proposes a general, theoretically-grounded yet simple approach ReMO, w
C语言-二维数组two-dimensional-array-master.zip
最新发布
03-24
C语言-二维数组two-dimensional-array-master.zip
特殊矩阵——三对角矩阵(Tridiagonal Matrix)
热门推荐
Catherine的笔记
06-27 6万+
特殊矩阵——三对角矩阵(Tridiagonal Matrix) 1. 三对角矩阵的概念 三对角矩阵就是对角线、邻近对角线的上下次对角线上有元素，其他位置均为0的矩阵。 三对角矩阵是一种特殊的上Hessenberg矩阵（这个就是上三角矩阵加上下三角部分的第一条次对角线有元素，其他都为0元素）。 2. 三对角矩阵的特性 设一个n*n的方阵A，对于矩阵A中的任一元素aij，当|i-j|>1时，有aij=0(0≤i≤n
优先级队列(Priority Queue)
Catherine的笔记
06-05 2万+
优先级队列(Priority Queue) 注：队列是一种特征为FIFO的数据结构，每次从队列中取出的是最早加入队列中的元素。但是，许多应用需要另一种队列，每次从队列中取出的应是具有最高优先权的元素，这种队列就是优先级队列(Priority Queue)，也称为优先权队列。 1. 优先级队列的概念 1.1 优先级队列的定义 优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。
特殊矩阵——对称矩阵(Symmetric Matrix)
Catherine的笔记
06-26 2万+
特殊矩阵——对称矩阵(Symmetric Matrix) 注：压缩存储的矩阵可以分为特殊矩阵和稀疏矩阵。对于那些具有相同元素或零元素在矩阵中分布具有一定规律的矩阵，被称之为特殊矩阵。对于那些零元素数据远远多于非零元素数目，并且非零元素的分布没有规律的矩阵称之为稀疏矩阵。 1. 对称矩阵的概念 元素以主对角线为对称轴对应相等的矩阵。 2. 对称矩阵的特性 对角矩阵都是对称矩阵，对称矩阵必须是方形矩阵。 设一个n
迷宫问题(MazePath)的求解——利用回溯法(backtracking)
Catherine的笔记
05-25 2万+
迷宫问题(MazePath)的求解——利用回溯法(backtracking) 1. 迷宫问题的提法 迷宫问题是典型的图的搜索问题。 假设一个迷宫，只有一个入口和一个出口。如果从迷宫的入口到达出口，途中不出现行进方向错误，则得到一条最佳路线。 为此，用一个二维数组maze[m][n]来表示迷宫。 (1)当数组元素maze[i][j]=1 (0≤i≤m-1,1≤j≤n-1)，表示该位置是墙壁，不能通行。 (2)当
稀疏矩阵(Sparse Matrix)
Catherine的笔记
06-29 2万+
稀疏矩阵(Sparse Matrix) 注：压缩存储的矩阵可以分为特殊矩阵和稀疏矩阵。对于那些具有相同元素或零元素在矩阵中分布具有一定规律的矩阵，被称之为特殊矩阵。对于那些零元素数据远远多于非零元素数目，并且非零元素的分布没有规律的矩阵称之为稀疏矩阵。 1. 稀疏矩阵的概念 在矩阵中，若数值为0的元素数目远远多于非0元素的数目时，则称该矩阵为稀疏矩阵。与之相反，若非0元素数目占大多数时，则称该矩阵为稠密矩阵。
1-dimensional array given. Array must be at least two-dimensional
05-25
To convert a 1-dimensional array into a 2-dimensional array, you need to decide on the number of rows and columns for the new array. The total number of elements in the 1-dimensional array should be equal to the product of the number of rows and columns in the 2-dimensional array. Here's an example code snippet in Python that converts a 1-dimensional array of length n into a 2-dimensional array of size m x n: ``` import numpy as np # define input 1D array arr_1d = np.array([1, 2, 3, 4, 5, 6]) # define number of rows and columns for 2D array m = 2 n = 3 # convert 1D array to 2D array arr_2d = arr_1d.reshape(m, n) print(arr_2d) ``` Output: ``` array([[1, 2, 3], [4, 5, 6]]) ``` The `reshape()` function is used to transform the 1D array into a 2D array of size `m` rows and `n` columns. The resulting array will have `m*n` elements, which should match the size of the original 1D array.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值