实际需求

就像五子棋盘，要保存这局棋。可以用二维数组，1表示黑棋，2表示蓝棋，0表示空位。但是问题来了，我现在就两个棋子，其他的都是空位，而这二维数组0太多了，保存下来占用空间。要是这棋盘很大，占用空间更明显。
image.png

基本介绍

当一个数组的大部分元素为0或者为同一个值。可以使用稀疏数组来保存该数组。稀疏数组只有在数据稀疏的情况下有优势。

稀疏数组的处理方法

  1. 记录数组一共有几行几列，多少个不同的值
  2. 把具有不同值得元素的行列以及值记录在一个小规模的数组中，从而缩小程序的规模。这个小规模的数组就是稀疏数组。

原始数组像这样。保存原始数组就要保存15*15=225个数据。

image.png
稀疏数组像这样，前两列记录数据的坐标，第三列记录数据，这样只用保存8*3=24个数据。
image.png

稀疏数组的转换思路

稀疏数组行数不确定，列是固定的3列，第一列记录行坐标，第二列记录列坐标，第三列记录值。
稀疏数组第一行记录原始数组的行，列，有多少个有效数。

二维数组转稀疏数组的思路

  1. 遍历原始的二维数组，得到有效数据的个数s
  2. 根据s就可以创建稀疏数组sparseArr int[s+1][3]
  3. 稀疏数组第一行记录原始数组的行数和列数，还有有效数据个数

  4. 将二维数组的有效数据存入到稀疏数组，从第二行开始

    稀疏数组转原始二维数组的思路

  5. 先读取稀疏数组的第一行，根据第一行的数据，创建原始二维数组，空数组

  6. 再读取稀疏数组后几行的数据，并赋值给创建的原始数组即可。

    代码实现

    ```csharp using System; namespace ConsoleApp1 { class Program {

    1.  static void Main(string[] args)
    2.  {
    3.      //原始二维数组
    4.      int[,] Arr = new int[15, 15];
    5.      Arr[1, 2] = 1;
    6.      Arr[2, 4] = 2;
    7.      Arr[3, 7] = 4;
    9.      PrintArr(Arr);
    10.      ArrToSparseArr(Arr);
    11.  }
    13.  //打印二维数组
    14.  static void PrintArr(int[,] Arr)
    15.  {
    16.      for (int i = 0; i < Arr.GetLength(0); i++)
    17.      {
    18.          for (int t = 0; t < Arr.GetLength(1); t++)
    19.          {
    20.              Console.Write(Arr[i, t]);
    21.          }
    22.          Console.WriteLine("\r");
    23.      }
    24.  }
    26.  //原始数组转稀疏数组
    27.  static void ArrToSparseArr(int[,] Arr)
    28.  {
    29.      //1.先遍历二维数组得到非0有效数据个数
    30.      int sum = 0;//有效数据个数
    31.      for (int i = 0; i < 15; i++)
    32.      {
    33.          for (int t = 0; t < 15; t++)
    34.          {
    35.              if (Arr[i, t] != 0)
    36.                  sum++;
    37.          }
    38.      }
    40.      //2.创建稀疏数组
    41.      int[,] sparseArr = new int[sum + 1, 3];
    42.      sparseArr[0, 0] = 15;
    43.      sparseArr[0, 1] = 15;
    44.      sparseArr[0, 2] = sum;
    46.      //3.遍历二维数组，将非0的有效数存放到稀疏数组中去
    47.      int count = 0;//用来记录是第几个非0有效数
    48.      for (int i = 0; i < 15; i++)
    49.      {
    50.          for (int t = 0; t < 15; t++)
    51.          {
    52.              if (Arr[i, t] != 0)
    53.              {
    54.                  count++;
    55.                  sparseArr[count, 0] = i;
    56.                  sparseArr[count, 1] = t;
    57.                  sparseArr[count, 2] = Arr[i, t];
    58.              }
    59.          }
    60.      }
    62.      //打印稀疏数组
    63.      Console.WriteLine("稀疏数组如下");
    64.      PrintArr(sparseArr);
    66.      //稀疏数组转原始数组
    67.      SparseArrToArr(sparseArr);
    68.  }
    70.  //稀疏数组转原始数组
    71.  static void SparseArrToArr(int[,] SparseArr)
    72.  {
    73.      //1.通过稀疏数组第一行创建原始数组
    74.      int[,] Arr = new int[SparseArr[0, 0], SparseArr[0, 1]];
    76.      //2.遍历稀疏数组剩下的行，赋值给原始数组
    77.      for(int i = 1; i < SparseArr.GetLength(0); i++)
    78.      {
    79.          Arr[SparseArr[i, 0], SparseArr[i, 1]] = SparseArr[i, 2];
    80.      }
    82.      //打印原始数组
    83.      PrintArr(Arr);
    84.  }

    } }

``` image.png