C#学习day05__数组以及遍历

什么是数组？
数组把相同数据类型存储到同一个单元里组成的构造类型
数组的每一个成员叫做数组元素

一维数组定义：
数据类型[] 数组名

//一组年龄
int[] age;

一维数组的初始化
在定义数组之后要对其进行初始化才能使用。

动态初始化

//数据类型[] 数组名称 = new 数据类型[数组长度]
int[] array = new int[3];
//数据类型[] 数组名称 = new 数据类型[数组长度]{数组元素};
int[] array = new int[3]{1,2,3};

静态初始化

//数据类型[] 数组名 = {数组元素};
int[] array= {1,2,3};

在这种情况下，不能将数组定义和静态初始化分开

数组的访问
元素访问
数组名称[下标] array[1] （下标从0开始计算）
数组下标可以是常量也可以是变量
数组名称.length 表示数组长度

数组赋值
数组属于一种引用类型，因此，当把b的数组名赋值给数组a时，那么在操作数组b的时候，实质上操作的还是数组a，如下图所示

系统不会检测数组下标是否越界，因此，编程的时候必须确保下标没有越界。
数组是一个整体，不能直接参加运算（=除外），只能对单个数组元素进行处理，一般用到数组的地方都会用到循环。

二维数组
有两个下标的数组叫做二维数组（也叫多维数组），实际上是以数组作为数组元素的数组，即数组的数组。
int[,] array = new int[,]{{},{}};

二维数组的初始化
动态初始化

//数据类型[,] 数组名称 = new 数据类型[常量表达式1,常量表达式2]{{},{}};
int[2,3] array = new int[2,3]{{1,2,3},{4,5,6}};
//二维数组元素的访问
//数组名[下标,下标]
Console.WriteLine(a[1,2]);

迭代遍历foreach
foreach(迭代类型 迭代变量名 in 迭代集合){
//循环体
}
迭代类型必须和后面的迭代集合保持一致，可以使用模糊数据类型var
迭代集合可以使数组、字符串、集合等

练习：
创建一个一维数组 ，并反向打印数组，求数组元素和，打印数组中最大和最小

int[] intArr = {2,3,5,7,11,13,17 };
//反向打印数组
for (int i = intArr.Length;i > 0;i--)
{
   Console.WriteLine(intArr[i - 1]);
}

//求数组元素和
int num = 0;
for (int i = intArr.Length; i > 0; i--)
{
   num += intArr[i - 1];
}
Console.WriteLine("num = " + num);

//打印数组中最大和最小
int max = intArr[0];
int min = intArr[0];
for (int i = 0;i < intArr.Length;i++)
{
	if (intArr[i] > max)
	{
		//最大值赋值
	    max = intArr[i];
	}
	else if(intArr[i] < min)
	{
		//最小值赋值
	    min = intArr[i];
	}
}
Console.WriteLine("max = " + max);
Console.WriteLine("min = " + min);

冒泡排序两种方法，结果是一样的，代码细微不同

            //冒泡排序
            int[] array = { 9, 3, 5, 1, 3, 98 };
            //从前向后比较，把比较大的放后面
            //比较轮数  length - 1
            for (int i = 0;i <= array.Length - 1;i++)
            {
                //每轮比较次数 Length - i - 1
                //因为比较的是第i个数以及后面的，所以是Length - i - 1
                for (int j = 0;j < array.Length - i - 1;j++)
                {
                    if (array[j] >= array[j + 1])
                    {
                    	//交换数值  temp用来临时存储数值方便交换
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
                //降序打印数组
                Console.Write(array[array.Length - i - 1] + "-");
            }
            Console.Write("\n");

            //升序打印数组
            for (int i = 0;i < array.Length;i++)
            {
                Console.Write(array[i] + "-");
            }

 - //冒泡排序
               int[] array1 = { 9, 3, 5, 1, 3, 98 };
               //从后向前比较，把比较小的放前面
               for (int i = array1.Length - 1; i >= 0; i--)
               {
   
                   //比较次数 Length - 2
                   for (int j = array1.Length - 2; j >= 0; j--)
                   {
                       if (array1[j] >= array1[j + 1])
                       {
                           int temp = array1[j];
                           array1[j] = array1[j + 1];
                           array1[j + 1] = temp;
                       }
                   }            
                   //升序打印数组
                   Console.Write(array1[array1.Length - i - 1] + "-");
               }

选择排序

            //选择排序      交换次数少
            int[] array2 = { 3, 6, 1, 3, 0, 9 };
            for (int i = 0; i < array2.Length - 1; i++)
            {
            	/*
                记录当前的索引（index）和值（num）
                通俗来讲就是，有一排苹果，想按照质量从小到大排列好
                第一个苹果写到记事本上，向后依次比较，发现第j个比第一个更小
                记事本：index：1号苹果， num：3kg
                于是在记事本上把第j个和第一个苹果索引和值换一下，然后在继续向后比较
                记事本：index：j号苹果， num：2kg 
                比较到最后记事本上写的就是质量最小的，把这个最小的和第一个位置互换
                一轮下来第一个碗里就是质量最小的
                */
                int index = i;
                int num = array2[i];
                for (int j = i + 1; j < array2.Length; j++)
                {
                //比较
                    if (num > array2[j])
                    {
                        //更改记录
                        //更改索引
                        index = j;
                        //更改值
                        num = array2[j];
                    }
                }
                //临时变量temp，用于接收此时第i个元素
                int temp = array2[i];
                //把此时的元素（num）赋给第i个位置
                array2[i] = num;
                //把temp赋给第（index = j）个位置
                array2[index] = temp;
            }

            //升序打印数组
            for (int i = 0; i < array2.Length; i++)
            {
                Console.Write(array2[i] + "-");
            }

插入排序

            //插入排序
            int[] array3 = { 16,5,1,96,2,3,};
            for (int i = 0;i < array3.Length - 1;i++)
            {
                for (int j = i + 1;j > 0;j--)
                {
                    if (array3[j] < array3[j - 1])
                    {
                        int temp = array3[j];
                        array3[j] = array3[j - 1];
                        array3[j - 1] = temp;
                    }
                }
            }
            //升序打印数组
            for (int i = 0;i < array3.Length;i++)
            {
                Console.WriteLine(array3[i]);
            }

遍历数组

//遍历二维数组找出最大值
            int[,] a = new int[3, 4] { {1,2,3,4 },{5,6,7,8 },{7,8,9,10 } };
            //先令a[1, 1]为最大值
            int max = a[1, 1];
            //表示二维数组的第i个数组
            for (int i = 0;i < 3;i++)
            {
            	//表示二维数组的第i个数组的第j个元素
                for (int j = 0;j < 4;j++)
                {
                	//让第i个数组的第j个元素和max作比较
                    if (a[i,j] > max)
                    {
                    	//如果比max大，就把第i个数组的第j个元素赋给max
                        max = a[i, j];
                    }
                }
            }
            Console.WriteLine("max = " + max);

            Console.WriteLine("-----------------------------");

			//foreach遍历数组
            int[] intArr = { 1,2,3,4,5};
            foreach (int tmp in intArr)
            {
                Console.Write(tmp);
            }

            Console.WriteLine("-----------------------------");
			//foreach遍历二位数组
            int[,] intArr2 = new int[2,3] { { 1, 2, 3 }, { 4, 5, 6 } };

            foreach (int tmp1 in intArr2)
            {
                Console.Write(tmp1);
            }