.Net学习笔记3-.Net基础1.3 方法与递归

方法(Methon).或函数（Function）
方法主要格式：
返回值类型 方法名(参数类型 参数1,参数类型 参数2……)

{

}
目前来讲所有方法都先加上static，以后讲why
封装一下GetMax方法:
static int GetMax(int[] nums)//参数的名字只在方法内部使用，和调用方法中的参数名字无关
{

int max=num[0];

for(int i=1;i<nums.Length;i++)

{

int num=nums[i];

if(num>max)

{

max=num;

}
}

return max;//把执行结果返回

}
调用方法： GetMax(x);

方法就是一堆可以重复使用（复用）的代码段。

执行过程中无法确定的数据以参数形式传递；方法的执行结果以返回值进行返回。不能在方法中定义方法。

方法可以没有参数；方法可以没有返回值（void）。

return：方法中用return返回处理结果，执行return之后方法内部的代码就执行结束了
如果没有返回值，则在需要执行结束的地方return;如果没写return，则在最后一句return；
方法中的局部变量不能被调用的方法访问，如果真要访问只能通过参数传值，
并且只是相当于变量赋值，方法内部对参数的赋值不会影响调用者。方法也不能调用调用者的局部变量。
一个问题：不是所有路径都有返回值。
必须方法的所有执行路径都要有返回值

两个方法名字相同，参数不同才能构成重载，和返回值无关；
编写一个获得String[]最长元素的方法GetMax
static string GetMax(string[] nums)
{

string max=num[0];

for(int i=1;i<nums.Length;i++)

{

string num=nums[i];

if(num.length>max.length)

{

max=num;

}
}
return max;//把执行结果返回
}
重载（OverLoad）：在同一个类中，允许存在一个以上的同名方法，只要其参数个数或者参数类型不同即可。
返回值是否一样无关。如果只是参数名字不一样，也不能构成合法的重载。
即：只有参数类型或者个数不一样，方法才能重名，和参数的名字、返回值类型都没有关系。
编译器怎么样知道应该调用哪个？
只调用参数类型相同的方法；GetMax(string[])调用第二个，GetMax(int[])调用第一个
之前我们用过的方法重载。Console.WriteLine()

int sum(params int[] nums);
就可以这样自由调用sum(3,5);sum(3,9,11,22,5);
这些参数其实还是以数组形式传递过去，在sum看来也是数组，
只不过编译器会自动把参数封装为数组，简化了调用。通过神器ILSpy可看出
可变参数可以声明为各种类型：test1(String... values)
可变参数前面还可以有其他参数，
可变长度参数params，params必须是最后一个参数，而且是数组类型；
sum(int name,params string[] data)。

i++：先取值再自增
++i：先自增再取值
i=i+1:赋值表达式也是一个值，这个值就是赋值之后=号左边的值

高效率的学习：
同一时间只做一件事情

一件事情一次性完成

递归：方法自己调用自己

两个条件：递推方法；递归的终止条件：什么情况下不再递归。

static void JGS(int i)

 {

            Console.WriteLine("从前有座山...讲的什么故事呢？" + i);

            if (i <= 5)

             {

            i++;

           JGS(i);//c#代码中执行完第一行代码才会继续往下执行第二行代码，被调用的方法执行完返回后才会往下继续执行

           Console.WriteLine("讲完了"+i);

             }
             
             }

如果没有终止条件，会一直执行下去，直到抛出异常（StackOverflowException）：栈内存溢出，

每执行一次JSG（i），都会在栈里面创建一块内存储存int i

每次调用方法，都会为方法创建一块内存空间，一个方法的两次调用就会有两块内存空间

他们的局部变量是不互相影响的、是独立的

c#代码中执行完第一行代码才会继续往下执行第二行代码，被调用的方法执行完返回后才会往下继续执行

阶乘：

//递推方法：f(n)=n*f(n-1)    5!=5*4*3*2*1

//终止条件： n=0 return 1

static int JC(int n)

        {

            if (n < 0)

            {

                throw new Exception("n不能是负数");

            }

            if (n == 0)

            {

                return 1;

            }

            return n * (JC(n - 1));

        }

斐波那契数列:

//1,1,2,3,5,8,13,21.....第n位（从0开始）值是多少？

        //递推方法：f(n)=f(n-1)+f(n-2)。终止条件：n=0,1 return 1。

        static int fib(int n)

        {

            if (n < 0)

            {

                throw new Exception("n不能是负数");

            }

            if (n == 0 || n == 1)

            {

                return 1;

            }

            return fib(n - 1) + fib(n - 2);

        }

//n从1开始计算

private static int Fib4(int n)

        {

            if (n < 1)

            {

                throw new Exception("n需大于0");

            }

            if (n == 1 || n == 2)

            {

                return 1;

            }

            return Fib(n - 2) + Fib(n - 3);

        }

递归的缺点：效率低，占内存  有的递归算法可以转为非递归算法

当你无法预测到底要递归多少次的时候用非递归算法更加恰当

非递归算法：

阶乘：

static int jiecheng2(int n)

        {

            if (n < 0)//参数合法性校验是面试时候的加分项！

            {

                throw new Exception("n不能是负数");

            }

            //n=3 n*(n-1)*(n-2)*1=3*2*1*1

            int result = 1;

            for (int i = 1; i <= n; i++)

            {

                result = result * i;

            }

            return result;

        }

菲波数列：

private static int Fib2(int n)

        {

            if (n < 0)

            {

                throw new Exception("n不能为负数");

            }

            if (n == 0 || n == 1)

            {

                return 1;

            }

            int[] nums = new int[n+1];

            nums[0] = 1;

            nums[1] = 1;

            for (int i = 2; i < n+1; i++)

            {

                nums[i] = nums[i-1] + nums[i-2];

Console.WriteLine(string.Join(",",nums));//string.Join把一个集合用某个分隔符拼接起来，成为字符串

            }

            return nums[n];

        }

private static int Fib3(int n)

        {

            if (n < 0)

            {

                throw new Exception("n不能为负数");

            }

            int i1 = 1;

            int i2 = 1;

            int i3 = 0;

            for (int i = 1; i < n; i++)

            {

                i3 = i1;

                i1 = i2;

                i2 = i1 + i3;

            }

            return i2;

        }