跳到主要内容

C#锯齿形数组

提示
  1. 锯齿形数组的定义：C#中的锯齿数组是由多个大小可变的数组构成的数组，与固定大小的多维数组不同。
  2. 声明和初始化方法：锯齿数组通过特定语法声明，并可通过索引、直接初始化或声明时初始化的多种方式进行赋值。
  3. 访问和遍历元素：锯齿数组的元素通过索引号访问，可使用嵌套循环遍历每个子数组的所有元素。

在 C# 中，锯齿数组由多个数组作为其元素组成。然而，与多维数组不同的是，锯齿数组内的每个数组可以有不同的大小。

在学习锯齿数组之前，请确保你了解以下内容：

C# 锯齿数组声明​

以下是在 C# 中声明锯齿数组的语法。

dataType[ ][ ] nameOfArray = new dataType[行数][ ];

我们来看一个示例，

// 声明锯齿数组
int[ ][ ] jaggedArray = new int[2][ ];

这里，

  • int - 数组的数据类型
  • [][] - 表示锯齿数组
  • jaggedArray - 锯齿数组的名称
  • [2][] - 表示锯齿数组内元素（数组）的数量

由于我们知道锯齿数组的每个元素也是一个数组，我们可以设置单个数组的大小。例如，

// 将第一个数组的大小设置为 3
jaggedArray[0] = new int[3];

// 将第二个数组的大小设置为 2
jaggedArray[1] = new int[2];

初始化锯齿数组​

有不同的方法可以初始化锯齿数组。例如，

1. 使用索引号

一旦我们声明了一个锯齿数组，我们就可以使用索引号来初始化它。例如，

// 初始化第一个数组
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;

// 初始化第二个数组
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

这里，

  • 第一个方括号中的索引代表锯齿数组元素的索引
  • 第二个方括号中的索引代表锯齿数组每个元素内的元素的索引

2. 在不设置数组元素大小的情况下初始化

// 声明字符串锯齿数组
int[ ][ ] jaggedArray = new int[2] [ ];

// 初始化每个数组
jaggedArray[0] = new int[] {1, 3, 5};
jaggedArray[1] = new int[] {2, 4};

3. 声明时初始化锯齿数组

int[ ][ ] jaggedArray = {
    new int[ ] {10, 20, 30},
    new int[ ] {11, 22},
    new int[ ] {88, 99}
};

访问锯齿数组的元素​

我们可以使用索引号访问锯齿数组的元素。例如，

// 访问第二个数组的第一个元素
jaggedArray[1][0];

// 访问第二个数组的第二个元素
jaggedArray[1][1];

// 访问第一个数组的第二个元素
jaggedArray[0][1];

示例：C# 锯齿数组​

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

     // 创建一个锯齿数组
     int[ ][ ] jaggedArray = {
         new int[] {1, 3, 5},
         new int[] {2, 4},
      };

     // 打印锯齿数组的元素
     Console.WriteLine("jaggedArray[1][0]: " + jaggedArray[1][0]);
     Console.WriteLine("jaggedArray[1][1]: " + jaggedArray[1][1]);

     Console.WriteLine("jaggedArray[0][2]: " + jaggedArray[0][2]);

     Console.ReadLine();
    }
  }
}

输出

jaggedArray[1][0]: 2
jaggedArray[1][1]: 4
jaggedArray[0][2]: 5

在这个锯齿数组中，

  • jaggedArray[1][0] - 第二个数组的第一个元素
  • jaggedArray[1][1] - 第二个数组的第二个元素
  • jaggedArray[0][2] - 第一个数组的第三个元素

遍历锯齿数组​

在 C# 中，我们可以使用循环遍历锯齿数组的每个元素。例如，

using System;

namespace JaggedArray {
  class Program {
    static void Main(string[] args) {

      // 声明一个锯齿数组
      int[][] jaggedArray = new int[2][];

      // 设置锯齿数组元素的大小
      jaggedArray[0] = new int[3];
      jaggedArray[1] = new int[2];

      // 初始化第一个数组
      jaggedArray[0][0] = 1;
      jaggedArray[0][1] = 3;
      jaggedArray[0][2] = 5;

      // 初始化第二个数组
      jaggedArray[1][0] = 2;
      jaggedArray[1][1] = 2;

      // 外层 for 循环
      for (int i = 0; i < jaggedArray.Length; i++) {

        Console.Write("元素 "+ i +": ");
        // 内层 for 循环
        for (int j = 0; j < jaggedArray[i].Length; j++) {
          Console.Write(jaggedArray[i][j] + " ");
         }
      Console.WriteLine();
      }
      Console.ReadLine();
    }
  }
}

输出

Element 0: 1 3 5
Element 1: 2 2

在上面的例子中，我们使用了 嵌套循环 来遍历不规则数组。这里，

1. 外层 for 循环

  • 用于访问不规则数组的元素（数组）
  • jaggedArray.Length - 返回不规则数组的大小

2. 内层 for 循环

  • 用于访问不规则数组内部单个数组的元素。
  • jaggedArray[i].Length - 返回 i 个数组内部元素的大小

多维数组中的不规则数组​

在 C# 中，我们也可以使用多维数组作为不规则数组元素。例如，

int[ ][ , ] jaggedArrayTwoD = new int[2][ , ] {
    	new int[,] { {1, 8}, {6, 7} },
    	new int[,] { {0, 3}, {5, 6}, {9, 10} }
};

这里，不规则数组的每个元素都是一个多维数组：

  • new int[,] { {1, 8}, {6, 7} } - 有2个元素的二维数组
  • new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 有3个元素的二维数组

我们来看一个例子，

using System;

namespace JaggedArray  {
  class Program {
    static void Main(string[] args)  {

      // 声明并初始化包含2D数组的不规则数组
      int[][,] jaggedArray = new int[3][ , ]  {
          new int[ , ] { {1, 8}, {6, 7} },
          new int[ , ] { {0, 3}, {5, 6}, {9, 10} },
          new int[ , ] { {11, 23}, {100, 88}, {0, 10} }
      };

      Console.WriteLine(jaggedArray[0][0, 1]);
      Console.WriteLine(jaggedArray[1][2, 1]);
      Console.WriteLine(jaggedArray[2][1, 0]);

      Console.ReadLine();
    }
  }
}

输出

8
10
100

在上面的例子中，请注意代码，

jaggedArray[0][0, 1]

这里，

  • [0] - 表示不规则数组的第一个元素（二维数组）
  • [0, 1] - 表示二维数组内第一个数组的第二个元素
最后于 更新