C++

多维数组

定义：多维数组可以看作是数组的数组，通过在定义时指定每个维度的大小来创建。下面以三维数组为例。

访问：使用多个索引来访问数组中的元素，索引从 0 开始。

销毁：对于栈上定义的多维数组，当作用域结束时会自动销毁；对于堆上动态分配的多维数组，需要手动释放内存。

#include <iostream>
int main() {
    // 定义一个三维数组，大小为2x3x4
    int multiDimArray[2][3][4];
    // 初始化三维数组元素
    int value = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                multiDimArray[i][j][k] = value++;
            }
        }
    }
    // 访问并输出三维数组元素
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                std::cout << "multiDimArray[" << i << "][" << j << "][" << k << "] = " << multiDimArray[i][j][k] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
    // 动态分配三维数组
    int*** dynamicMultiDimArray = new int** [2];
    for (int i = 0; i < 2; i++) {
        dynamicMultiDimArray[i] = new int* [3];
        for (int j = 0; j < 3; j++) {
            dynamicMultiDimArray[i][j] = new int[4];
        }
    }
    // 初始化动态分配的三维数组元素
    value = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                dynamicMultiDimArray[i][j][k] = value++;
            }
        }
    }
    // 访问并输出动态分配的三维数组元素
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 4; k++) {
                std::cout << "dynamicMultiDimArray[" << i << "][" << j << "][" << k << "] = " << dynamicMultiDimArray[i][j][k] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
    // 销毁动态分配的三维数组
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            delete[] dynamicMultiDimArray[i][j];
        }
        delete[] dynamicMultiDimArray[i];
    }
    delete[] dynamicMultiDimArray;
    return 0;
}

锯齿数组

在 C++ 中，锯齿数组即不规则的多维数组，每一行的长度可以不同

定义：通过动态分配内存来创建每一行，使每行具有不同的长度。

访问：通过行和列索引来访问元素，但要注意每行的长度不同。

销毁：手动释放每一行分配的内存，以及存储行指针的数组。

#include <iostream>
int main() {
    // 定义一个锯齿数组，有3行
    int** jaggedArray = new int* [3];
    // 第一行有2个元素，第二行有3个元素，第三行有4个元素
    jaggedArray[0] = new int[2];
    jaggedArray[1] = new int[3];
    jaggedArray[2] = new int[4];
    // 初始化锯齿数组元素
    int value = 0;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < (i + 2); j++) {
            jaggedArray[i][j] = value++;
        }
    }
    // 访问并输出锯齿数组元素
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < (i + 2); j++) {
            std::cout << "jaggedArray[" << i << "][" << j << "] = " << jaggedArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    // 销毁锯齿数组
    for (int i = 0; i < 3; i++) {
        delete[] jaggedArray[i];
    }
    delete[] jaggedArray;
    return 0;
}

C#

多维数组

定义：使用new关键字和指定的维度大小来创建多维数组。

访问：通过多个索引访问数组元素，索引从 0 开始。

销毁：C# 有垃圾回收机制，当多维数组不再被引用时，垃圾回收器会自动回收其占用的内存。

using System;
class Program {
    static void Main() {
        // 定义一个三维数组，大小为2x3x4
        int[,,] multiDimArray = new int[2, 3, 4];
        // 初始化三维数组元素
        int value = 0;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 4; k++) {
                    multiDimArray[i, j, k] = value++;
                }
            }
        }
        // 访问并输出三维数组元素
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 4; k++) {
                    Console.WriteLine($"multiDimArray[{i}, {j}, {k}] = {multiDimArray[i, j, k]}");
                }
            }
        }
    }
}

锯齿数组

定义：先定义一个一维数组来存储每行的数组引用，然后为每行分配不同大小的数组。

访问：通过行和列索引访问元素，注意每行长度不同。

销毁：C# 的垃圾回收机制会自动处理锯齿数组的内存回收。

using System;
class Program {
    static void Main() {
        // 定义一个锯齿数组，有3行
        int[][] jaggedArray = new int[3][];
        // 第一行有2个元素，第二行有3个元素，第三行有4个元素
        jaggedArray[0] = new int[2];
        jaggedArray[1] = new int[3];
        jaggedArray[2] = new int[4];
        // 初始化锯齿数组元素
        int value = 0;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < (i + 2); j++) {
                jaggedArray[i][j] = value++;
            }
        }
        // 访问并输出锯齿数组元素
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < (i + 2); j++) {
                Console.WriteLine($"jaggedArray[{i}][{j}] = {jaggedArray[i][j]}");
            }
        }
    }
}

Python

多维列表（模拟多维数组）

定义：通过嵌套列表来创建多维列表。下面以三维列表为例。

访问：使用多个索引访问列表中的元素，索引从 0 开始。

销毁：Python 有垃圾回收机制，当多维列表不再被引用时，内存会被自动回收。

# 定义一个三维列表，大小为2x3x4
multiDimList = [[[0 for _ in range(4)] for _ in range(3)] for _ in range(2)]
# 初始化三维列表元素
value = 0
for i in range(2):
    for j in range(3):
        for k in range(4):
            multiDimList[i][j][k] = value
            value += 1
# 访问并输出三维列表元素
for sublist1 in multiDimList:
    for sublist2 in sublist1:
        for value in sublist2:
            print(value, end=' ')
        print()
    print()

锯齿列表（模拟锯齿数组）

定义：通过创建不同长度的子列表来模拟锯齿数组。

访问：使用行和列索引访问元素，注意每行长度不同。

销毁：Python 的垃圾回收机制会自动处理锯齿列表的内存回收。

# 定义一个锯齿列表，有3行
jaggedList = []
jaggedList.append([0] * 2)
jaggedList.append([0] * 3)
jaggedList.append([0] * 4)
# 初始化锯齿列表元素
value = 0
for i in range(len(jaggedList)):
    for j in range(len(jaggedList[i])):
        jaggedList[i][j] = value
        value += 1
# 访问并输出锯齿列表元素
for sublist in jaggedList:
    for value in sublist:
        print(value, end=' ')
    print()