C# 交错数组

在 C# 中，交错数组的元素是多个数组。但是，与多维数组不同的是，交错数组中的每个数组的大小都可以不同。

在学习交错数组之前，请确保您了解

• C# 数组
• C# 多维数组

C# 交错数组声明

以下是声明 C# 交错数组的语法。

dataType[ ][ ] nameOfArray = new dataType[rows][ ];

让我们看一个例子，

// declare jagged array
int[ ][ ] jaggedArray = new int[2][ ];

这里，

• int - 数组的数据类型
• [][] - 表示交错数组
• jaggedArray - 交错数组的名称
• [2][] - 表示交错数组中的元素（数组）数量

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

// set size of the first array as 3
jaggedArray[0] = new int[3];

// set size of second array as 2
jaggedArray[1] = new int[2];

初始化交错数组

有多种初始化交错数组的方法。例如，

1. 使用索引号

声明交错数组后，我们可以使用索引号对其进行初始化。例如，

// initialize the first array
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 3;
jaggedArray[0][2] = 5;

// initialize the second array
jaggedArray[1][0] = 2;
jaggedArray[1][1] = 4;

这里，

• 第一个方括号中的索引表示交错数组元素的索引
• 第二个方括号中的索引表示交错数组中每个元素内元素的索引

2. 初始化时不设置数组元素的大小

// declaring string jagged array
int[ ][ ] jaggedArray = new int[2] [ ];

// initialize each array
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}
};

访问交错数组的元素

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

// access first element of second array
jaggedArray[1][0];

// access second element of the second array
jaggedArray[1][1];

// access second element of the first array
jaggedArray[0][1];

示例：C# 交错数组

using System;

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

     // create a jagged array
     int[ ][ ] jaggedArray = {
         new int[] {1, 3, 5},
         new int[] {2, 4},
      };

     // print elements of jagged array
     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) {

      // declare a jagged array
      int[][] jaggedArray = new int[2][];

      // set size of Jagged Array Elements
      jaggedArray[0] = new int[3];
      jaggedArray[1] = new int[2];

      // initialize the first array
      jaggedArray[0][0] = 1;
      jaggedArray[0][1] = 3;
      jaggedArray[0][2] = 5;

      // initialize the second array
      jaggedArray[1][0] = 2;
      jaggedArray[1][1] = 2;
      	 
      // outer for loop
      for (int i = 0; i < jaggedArray.Length; i++) {

        Console.Write("Element "+ i +": ");
        // inner for loop
        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

在上面的示例中，我们使用了一个 嵌套 for 循环来遍历交错数组。这里，

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 个元素的 2D 数组
• new int[ , ] { {0, 3}, {5, 6}, {9, 10} } - 包含 3 个元素的 2D 数组

让我们看一个例子，

using System;

namespace JaggedArray  {
  class Program {
    static void Main(string[] args)  {
  	 
      // declare and initialize jagged array with 2D array
      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] - 表示交错数组的第一个元素（2D 数组）
• [0, 1] - 表示 2D 数组中第一个数组的第二个元素