foreach 循环遍历 以及函数的应用

foreach( 对集合每个元素的引用 in 集合 )
{

}

举例：

int[] a = new int[5]{1,2,3,4,5};
foreach( int b in a )
{
//b就是a中的每个元素
}

注意：
１.foreach只能对集合进行遍历。
２.foreach在操作集合的时候，只能读不能改；

3.foreach操作Dictionary<T,T>

Dictionary<string,string> dic = new Dictionary<string,string>();
//...添加值

foreach( KeyValuePare<string,string> b in dic)
{
}

4.foreach操作List<T>

List<int> list = new List<int>();
//添加值
foreach( int b in list )
{
}

5.foreach能够操作IEnumarable（IEnumarator）下的子级集合。

函数：
主要的功能就是为了让代码结构更加良好。
函数是——实现相对独立功能的程序代码模块（程序段）.
函数的四要素：函数名，输入，输出，运算

有的函数没有输入，函数名后的小括号中可以不写东西，但必须要有小括号。
有的函数没有返回，在函数名的左侧不要写数据类型了，写void即可.

定义语法：
static 返回类型 函数名(形参列表)
{
函数体,运算
}

static int Max(int a,int b)
{
　　if(a>b)
　　{
    　　return a;
　　}
　　else
　　{
    　　return b;
　　}
}

调用语法：
数据类型 变量名 = 函数名(实参列表);
int n = Max(7,8);

形参与实参一定要一一对应（个数，类型）

传值
把实参的数据做个复本，送到函数的形参中去。
一般基本类型(int,double,char,bool,DateTime)都是值类型，他们默认情况下会传值。

举例：

static void Main(string[] args)
        {
            int a = 10;
            Console.WriteLine(a);//???  10
            Add(a);
            Console.WriteLine(a);//???  10--实参的值传到调用的Add函数里，实参值并不改变，int型默认传值
        }
        static void Add(int x)
        {
            Console.WriteLine(x);//???  10
            x++;
            Console.WriteLine(x);//???  11
        }

运行结果：

传址
把实参的地址传组函数的形参中去。形参与实参共用同一个数据空间。
一般引用类型都是传地址的，如数组和字符串。

举例：

static void Main(string[] args)
        {
            int[] a = new int[3] {3,4,5 };
            //显示
            Show(a);            //3  4  5
            Add(a);
            //显示                //数组默认的是传址，就是将地址传到所调用的函数里面，实参的值也会跟着改变
            Show(a);           //103  104  105 
        }
        static void Show(int[] x)
        {
            foreach (int b in x)
            {
                Console.Write(b+"	");
            }
            Console.WriteLine();
        }
        static void Add(int[] x)
        {
            //显示
            Show(x);            //3  4  5
            for (int i = 0; i < x.Length; i++)
            {
                x[i] = x[i] + 100;
            }
            //显示                //103  104  105
            Show(x);
        }

运行结果：

练习题：

1.调用函数：青歌赛打分：２０位评委给一个选手打分，去掉一个最高分，去掉一个最低分求歌手的平均得分。

     static void Main1(string[] args)
        {
            //调用函数：青歌赛打分：２０位评委给一个选手打分，去掉一个最高分，去掉一个最低分求歌手的平均得分。

            //定义数组接收评委的分数
            int[] fenshu=new int[20];
            int max = 0, min = 10000,sum=0;

            //打分
            fenshu = Shuru(fenshu);

            //运算
            max = Max(fenshu);
            min = Min(fenshu);
            sum = Sum(fenshu);
            //输出
            Shuchu(fenshu,max,min,sum);
       
        }
        static int [] Shuru(int[]a)//#######输入函数
        {
            for (int i = 0; i <a.Length; i++)
            {
                Console.Write("请第{0}个评委打分：",i+1);
                a[i] = Convert.ToInt32(Console.ReadLine());
            }
            return a;
        }
        static int Max(int[] a)//#######求最大值函数
        {
            int zuida = 0;
            foreach (int b in a)
            {
                if (b>zuida)
                {
                    zuida = b;
                }
            }
            return zuida;
        }
        static int Min(int[] a)//#######求最小值函数
        {
            int zuixiao = 10000;
            foreach (int b in a)
            {
                if (b<zuixiao)
                {
                    zuixiao = b;
                }
            }
            return zuixiao;
        }
        static int Sum(int[] a)//#######求和函数
        {
            int sum = 0;
            for (int i = 0; i <a.Length; i++)
            {
                sum = sum + a[i];
            }
            return sum;
        }
        static void Shuchu(int[] a,int max,int min,int sum)//######输出函数
        {
            double avg =1.0* (sum - max - min) / (a.Length - 2);
            Console.WriteLine("去掉一个最高分{0}，去掉一个最低分{1}，该选手的平均得分是：{2}",max,min,avg);
        }

2.顺序查找法:输入一个数，看是否能在已知数组中找到，输出找到或没找到

 static void Main2(string[] args)
        { 
            //*******顺序查找法******* 

            int[] a=new int[]{12,23,33,45,65,42,78,66};
            //输入
            int n = Convert.ToInt32(Console.ReadLine());
            //查找
            bool find = found(a,n);
          

            //输出
            if (find==true)
            {
                Console.WriteLine("找到了");
            }
            else
            {
                Console.WriteLine("没找到");
            }
        }
        
        static bool found(int[] a, int n)
        {
            bool found = false;
            foreach (int b in a)
            {
                if (b==n)
                {
                    found = true;
                    break;
                }
            }
            return found;
        }

3.二分法查找，题目同上

static void Main3(string[] args)
        { 
        //*******二分法查找******
            int[] a = new int[] { 12, 23, 33, 45, 65, 42, 78, 66 };
            //输入
            int n = Convert.ToInt32(Console.ReadLine());

            //排序
            a = Shunxu(a);
            //查找（二分法）
            bool find = zhaodao(a,n);

            //输出
            if (find==true)
            {
                Console.WriteLine("找到了");
            }
            else
            {
                Console.WriteLine("没找到");
            }

        }
        static int[] Shunxu(int[] a)//排序函数，从小到大排序
        {
            for (int i = 1; i <= a.Length - 1; i++)
            {
                for (int j = 1; j <= a.Length - i; j++)
                {
                    if (a[j] < a[j - 1])
                    {
                        int z = a[j];
                        a[j] = a[j - 1];
                        a[j - 1] = z;
                    }
                }
            }
            return a;
        }
        static bool zhaodao(int[] a, int n)//查找函数
        {
            bool zhaodaole = false;
            int ks = 0, js = a.Length - 1, zj;
            for (; ; )
            {
                
                zj = (ks + js) / 2;
                if (a[zj]==n)
                {
                     
                    zhaodaole = true;
                    break;

                }
                else
                {
                    if (a[zj]>n)
                    {
                        js = zj - 1;
                    }
                    else
                    {
                        ks = zj + 1;
                    }
                    if (ks<js)
                    {
                        break;
                    }
                }
                
            }
            return zhaodaole;
        }