go语言递归函数原理 golang递归

先或后与

#include stdio.h

#include stdlib.h

#define MAX_LENGTH 6

int operators[MAX_LENGTH] = { 1,0,0,1,0,1 };

int operands[MAX_LENGTH + 1] = { 1,0,1,0,0,1,1};

//判断给定的运算符的优先级，高则返回1，低则返回0

int IsHigherOp(int op)

{

return op == 0 ? 1 : 0;

}

//根据你的需要定义运算函数，可以是简单的运算符或复杂运算过程

int MyOperation(int leftVal, int rightVal, int op)

{

if(IsHigherOp(op))

return leftVal || rightVal;

else

return leftVal  rightVal;

}

//三个全局变量，用于(仅用于)递归函数RecursivFun()中

int leftVal, rightVal, currentOp;

//递归函数原理：

//先按顺序取两个操作数，和一个操作符，分别记录在leftVal, rightVal, currentOp中，

//然后依次取下一个操作数和下一个操作符，这样就会有三个操作数和两个操作符，

//分别记作A,B,C,+(低优先级),*(高优先级), 则共有四种组合：A+B*C, A+B+C, A*B+C, A*B*C

//无论接下来是什么操作符，总可以将它们按如下形式计算，记录到上面的两个操作数和一个操作符变量中：

//A+B*C = A+(B*C)

//A+B+C = (A+B)+C

//A*B+C = (A*B)+C

//A*B*C = (A*B)*C

//注意：在主函数中，调用该函数时参数currentIndex必须是0，当然你可以扩展这个函数为

//      RecursivFun(int currentIndex, int minIndex, int maxIndex)使之可以从任意起点开始到任意终点结束

int RecursivFun(int currentIndex)

{

if(currentIndex == 0)

{

leftVal = operands[0];

rightVal = operands[1];

currentOp = operators[0];

}

if(currentIndex  MAX_LENGTH - 1)

{

if(IsHigherOp(operators[currentIndex + 1]))

rightVal = MyOperation(rightVal, operands[currentIndex + 2], operators[currentIndex + 1]);

else

{

leftVal = MyOperation(leftVal, rightVal, currentOp);

currentOp = operators[currentIndex + 1];

rightVal = operands[currentIndex + 2];

}

return RecursivFun(currentIndex + 1);

}

else

return MyOperation(leftVal, rightVal, currentOp);

}

int main()

{

printf("result: %d", RecursivFun(0));

return 0;

}

以上是通过递归函数写的， 当然也可以根据上述原理使用一个for循环来写个非递归形式的，此时可以用三个局部变量来代替上面的三个全局变量

这个程序应该比你想要的更具有通用性，你可以根据需要改成你想要的运算(甚至是复杂运算过程)， 比如加减乘除什么的。另外你可以方便的更改运算符的优先级。

另外一点，比较重要的，这种思想，是基于一遍扫描的，就是说，只需要对两个数组进行一遍扫描（即一次循环）即可得出结果。如果在一个效率比较重要的系统中， 这很重要，此时可以更改为一个for循环来代替递归。

相关问答

Q1: func函数是干什么的？

Func函数是包含在Function和End Function语句之间的一组VBScript语句。

Func函数与Sub过程类似。但Func函数可以有返回值。可以使用参数。如果Func函数没有任何参数，则Function语句必须要包含空括号。Func函数通过函数名返回一个值。返回值的数据类型是Variant。

语法： Function 函数名 （参数1，参数2，...)

...

End Function

func在go语言中的使用：

在 Go 语言中，函数声明通用语法如下：

func functionname(parametername type) returntype {  

  // 函数体（具体实现的功能）

}

函数的声明以关键词 func 开始，后面紧跟自定义的函数名 functionname (函数名)。函数的参数列表定义在 ( 和 ) 之间，返回值的类型则定义在之后的 returntype (返回值类型)处。

声明一个参数的语法采用 参数名 参数类型 的方式，任意多个参数采用类似 (parameter1 type, parameter2 type) 即(参数1 参数1的类型,参数2 参数2的类型)的形式指定。之后包含在 { 和 } 之间的代码，就是函数体。

Q2: 递归的原理解释

递归的底层实现其实是一个栈.栈的特点是后进先出,也就是最后进入栈的事件是最先被处理的.

递归就是这样运作.比如计算阶乘函数F(n)=n!=n*F(n-1)=....

写成递归,我用java

public static long F(long num){

if(num=1)

return 1;

return F(num-1)*num;

}

static public void main(String argv[]){

System.out.println(F(5));

}:

第一次计算的时候是F(num),进入之后会直接return F(num-1)*num.也就是把这一项入栈.

然后这一项到底是多少还不知道需要继续计算.

第二次递归就是 F(num-1-1)*(num-1).入栈.

直到满足num=1.计算出最后入栈的F(1)=1;return这句就限定了最终栈的大小.

然后开始出栈.第一个出栈的是F(1);已经计算得出是1;

第二个出栈是F(2).由F(1)可以得知F(2).

这样直到栈空,阶乘也就计算出来了.

递归的内部是栈实现的.理解了这个,你也可以自己写非递归的递归,也就是用栈实现的递归.

Q3: 递归函数的原理，麻烦通俗一点，谢谢

简单地说go语言递归函数原理，递归就是函数方法自我调用，使复杂问题一步一步朝目标简化。

如go语言递归函数原理： 典型的问题， 求n的阶乘

int product(int n)

{

if (n==1) return 1

else return n * product(n-1) // 用 n * product (n-1)

}

非递归算法：

int product(int n)

{

int result = 1;

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

{ result=result * i }

}

Q4: GO语言学习系列八——GO函数(func)的声明与使用

GO是编译性语言，所以函数的顺序是无关紧要的，为了方便阅读，建议入口函数 main 写在最前面，其余函数按照功能需要进行排列

GO的函数 不支持嵌套，重载和默认参数

GO的函数 支持 无需声明变量，可变长度，多返回值，匿名，闭包等

GO的函数用 func 来声明，且左大括号 { 不能另起一行

一个简单的示例：

输出为：

参数：可以传0个或多个值来供自己用

返回：通过用 return 来进行返回

输出为：

上面就是一个典型的多参数传递与多返回值

对例子的说明：

按值传递：是对某个变量进行复制，不能更改原变量的值

引用传递：相当于按指针传递，可以同时改变原来的值，并且消耗的内存会更少，只有4或8个字节的消耗

在上例中，返回值 (d int, e int, f int) { 是进行了命名，如果不想命名可以写成 (int,int,int){ ,返回的结果都是一样的，但要注意:

当返回了多个值，我们某些变量不想要，或实际用不到，我们可以使用 _ 来补位，例如上例的返回我们可以写成 d,_,f := test(a,b,c) ，我们不想要中间的返回值，可以以这种形式来舍弃掉

在参数后面以 变量 ... type 这种形式的，我们就要以判断出这是一个可变长度的参数

输出为：

在上例中， strs ...string 中， strs 的实际值是b,c,d,e,这就是一个最简单的传递可变长度的参数的例子，更多一些演变的形式，都非常类似

在GO中 defer 关键字非常重要，相当于面相对像中的析构函数，也就是在某个函数执行完成后，GO会自动这个；

如果在多层循环中函数里，都定义了 defer ,那么它的执行顺序是先进后出；

当某个函数出现严重错误时， defer 也会被调用

输出为

这是一个最简单的测试了，当然还有更复杂的调用，比如调试程序时，判断是哪个函数出了问题，完全可以根据 defer 打印出来的内容来进行判断，非常快速，这种留给你们去实现

一个函数在函数体内自己调用自己我们称之为递归函数，在做递归调用时，经常会将内存给占满，这是非常要注意的，常用的比如，快速排序就是用的递归调用

本篇重点介绍了GO函数(func)的声明与使用，下一篇将介绍GO的结构 struct

关于go语言递归函数原理和golang递归的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。