二维数组
```
//创建一个5行3列的二维数组
int[,] arr = new int[5, 3];
//arr.Length=5*3=15
arr.GetLength(0);//获取行数
arr.GetLength(1);//获取列数
//foreach也可以遍历整个二维数组
```
二维数组的练习：2048小游戏
核心思想
2048算法核心:
上移：1、从上往下获取列数据
2、合并数据
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将后一个数据累加到前一个数据上，并且后一个数据清零）
去零:合并之前，将0元素移到末尾
3、将一维数组元素还原至原列
下移1.0：
1、从上往下获取列数据
2、合并数据
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将前一个数据累加到后一个数据上，并且前一个数据清零）
去零:合并之前，将0元素移到末尾
3、将一维数组元素还原至原列
下移2.0：
1、从下往上获取列数据
2、合并数据
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将后一个数据累加到前一个数据上，并且后一个数据清零）
去零:合并之前，将0元素移到末尾
3、将一维数组元素还原至原列
左移： 1、从左往右获取行数据
2、合并数据
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将后一个数据累加到前一个数据上，并且后一个数据清零）
去零:合并之前，将0元素移到末尾
3、将一维数组元素还原至原列
右移：1、从右往左获取列数据
2、合并数据
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将后一个数据累加到前一个数据上，并且后一个数据清零）
去零:合并之前，将0元素移到末尾
3、将一维数组元素还原至原列
method1：1.定义去零方法（针对一维数组），将0元素移到末尾
method2：2.定义合并数据方法
去零:合并之前，将0元素移到末尾
要求：相邻相同的数据，合并（将后一个数据累加到前一个数据上，并且后一个数据清零）
去零:合并之前，将0元素移到末尾
method3：3.上移
从上往下获取列数据，形成一维数组
调用合并数据的方法
将一维数组还原至原列
method4：4.下移
从下往上获取列数据，形成一维数组
调用合并数据的方法
将一维数组还原至原列
method5: 5.左移
从左往右获取行数据，形成一维数组
调用合并数据的方法
将一维数组还原至原列
method5: 6.右移
从左往右获取行数据，形成一维数组
调用合并数据的方法
将一维数组还原至原列
实现
```
//将0元素移到末尾
private static int[] removeZeroToEnd(int[] array) {
//创建一个新的数组
int[] newArray = new int[array.Length];
int j = 0;
for (int i = 0; i < array.Length; i++)
{
if (array[i] != 0 )
newArray[j++] = array[i]; //将非0元素依次存入到一个新数组中
}
return newArray;
}
//合并数据的方法 返回合并后的数组
private static int[] merge(int[] array) {
//将0元素移到末尾 eg:2 0 2 4 ----> 2 2 4 0
array= removeZeroToEnd(array);
for (int i = 0; i < array.Length-1; i++)
{
//相邻相同 0 0不合
if (array[i]!=0 && array[i]==array[i+1])
{
array[i] += array[i + 1];//将后一个数据累加到前一个数据上
array[i + 1] = 0;//将后一个数据清零
}
}
array = removeZeroToEnd(array);
return array;
}
//上移
private static int[,] upMove(int[,] array) {
//从上到下获取数据，形成一维数组
//array.GetLength(1)-----列数
//array.GetLength(0)-----行数
int[] arr = new int[array.GetLength(0)];
//列数---形成一维数组的次数
for (int j = 0; j < array.GetLength(1); j++)
{
for (int i = 0; i < array.GetLength(0); i++)
//用一维数组去接收二维数组中某一列的全部数据（从上到下）
arr[i] = array[i, j];
arr = merge(arr);
//将合并后的数据重新填入到二维数组中
for (int i = 0; i < arr.Length; i++)
array[i, j] = arr[i];
}
return array;
}
//下移
private static int[,] downMove(int[,] array)
{
//从下到上获取数据，形成一维数组
//array.GetLength(1)-----列数
//array.GetLength(0)-----行数
int[] arr = new int[array.GetLength(0)];
//列数---形成一维数组的次数
for (int j = 0; j < array.GetLength(1); j++)
{
for (int i = array.GetLength(0)-1; i >=0; i--)
//用一维数组去接收二维数组中某一列的全部数据（从下到上）
arr[array.GetLength(0)- 1-i] = array[i, j];
arr = merge(arr);
//将合并后的数据重新填入到二维数组中
for (int i = array.GetLength(0) - 1; i>=0; i--)
array[i, j] = arr[array.GetLength(0)- 1-i];
}
return array;
}
//左移
private static int[,] leftMove(int[,] array) {
//定义一个数组用于接收某一列的数据
int[] arr = new int[array.GetLength(1)];
for (int j = 0; j < array.GetLength(0); j++)
{
for (int i = 0; i < array.GetLength(1); i++)
arr[i] = array[j, i];
arr=merge(arr);//数据合并
for (int i = 0; i < array.GetLength(1); i++)
array[j, i] = arr[i];
}
return array;
}
//右移
private static int[,] rightMove(int[,] array) {
int[] arr = new int[array.GetLength(1)];
for (int j = 0; j < array.GetLength(0); j++)
{
for (int i = array.GetLength(1) - 1; i >= 0; i--)
arr[array.GetLength(1) - i - 1] = array[j, i];//从右到左依次取数据
arr = merge(arr);
for (int i = array.GetLength(1) - 1; i >= 0; i--)
array[j, i] = arr[array.GetLength(1) - i - 1];
}
return array;
}
```
测试
```
//测试2048
int[,] map = new int[4, 4] {
{ 0,2,4,0 },
{ 2,4,4,2 },
{ 2,2,2,0 },
{ 0,2,2,2 },
};
printDoubleArray(map);
Console.WriteLine("上移");
upMove(map);
printDoubleArray(map);
Console.WriteLine("下移");
downMove(map);
printDoubleArray(map);
Console.WriteLine("左移");
leftMove(map);
printDoubleArray(map);
Console.WriteLine("右移");
rightMove(map);
printDoubleArray(map);
```
测试结果截图
交错数组：不规则的表格(用于图形不规则的游戏)
```
//交错数组 ---- 创建具有4个元素的交错数组
//交错数组的第一个元素是数组
//那么交错数组的第一个元素的第一个元素就是数据
int[][] arr1 = new int[4][];
//创建一维数组 赋值给 交错数组的第一个元素
arr1[0] = new int[3];
arr1[1] = new int[2];
arr1[2] = new int[4];
arr1[3] = new int[1];
//将数据 3 赋值给交错数组的第一个元素的第一个元素
arr1[0][0] = 3;
arr1[1][1] = 2;
arr1[1][0] = 6;
arr1[2][1] = 2;
//将数据1 赋值给 第i个元素的第j个元素-----arr1[i-1][j-1]=1
//交错数据的 foreach写法： 两层foreach
foreach (int[] arrSon in arr1)
{
foreach (var item in arrSon)
{
Console.Write(item + "\t");
}
Console.WriteLine();
}
//arr1.Length是交错数组的元素数，可以理解成行数
for (int i = 0; i < arr1.Length; i++)
{
for (int j = 0; j < arr1[i].Length; j++)
{
Console.Write(arr1[i][j] + "\t");
}
Console.WriteLine();
}
```
参数数组
```
//参数数组
//此写法的适用场景：返回类型明确，但是数据的个数不清楚
//params 参数数组：
//对于方法内部而言就是个普通数组
//对于方法外部(调用者)而言：
//可以传递数组、可以传递一组数据类型相同的变量集合
//可以不传递参数
//作用：简化调用者调用方法的代码
private static int addNum(params int[] array) {
int sum = 0;
//遍历数组
foreach (var item in array)
sum += item;
return sum;
}
main调用： int result = addNum(1, 2, 3, 4, 5);//适用参数数组的好处，可以直接传集合
int result2=addNum();//或者不填入任何值，程序的内部主要判断是否有params出现
```
