相互递归的功能 - 锻炼对我没有意义

时间:2013-08-21 20:24:29

标签: javascript

我知道这是确定偶数数字的愚蠢方法。这只是递归的一个教训,也可能是其他一些概念。

问题。

当我遵循逻辑时,看起来你给“n”的值无关紧要,它总是最终等于“0”并且总是以“假”结束。

发生了什么事?

function isOdd(x) {
    return !isEven(x);    
}

function isEven(x) {
    if(x===0) {
        return true;
    } else {
        return isOdd(x-1);
    }
}

4 个答案:

答案 0 :(得分:4)

这是isOdd在偶数上返回true的方式:

当你将2传递给isOdd时,它会将此转发给isEven。您的调用堆栈现在看起来像这样(最新功能已启动):

isEven(2)
isOdd(2)
main

isEven现在将使用1:

调用isOdd
isOdd(1)
isEven(2)
isOdd(2)
main

isOdd将再次转发给isEven:

isEven(1)
isOdd(1)
isEven(2)
isOdd(2)
main

整体再次发生0

isEven(0)
isOdd(0)
isEven(1)
isOdd(1)
isEven(2)
isOdd(2)
main

isEven现在终止为true,整个调用堆栈被重新启动。 True返回isOdd:

isOdd(0)   <-true
isEven(1)
isOdd(1)
isEven(2)
isOdd(2)
main

isOdd会否定返回值,因此将false返回给isEven:

isEven(1) <- false
isOdd(1)
isEven(2)
isOdd(2)
main

isEven再次将结果返回到isOdd

isOdd(1) <- false
isEven(2)
isOdd(2)
main

isOdd否定并返回:

isEven(2) <- true
isOdd(2)
main

isEven按原样返回:

isOdd(2) <- true
main

isOdd否定并返回main:

main <- false

这是isOdd如何在不均匀的数字上返回false:

当isEven终止时,调用堆栈看起来就像那样。

isEven(0)
isOdd(0)
isEven(1)
isOdd(1)
main

isOdd收到true:

isOdd(0) <-true
isEven(1)
isOdd(1)
main

isOdd否定:

isEven(1) <- false
isOdd(1)
main

isEven返回未更改的值:

isOdd(1) <- false
main

isOdd否定并返回main:

main <- true

那么解释是什么?

整个技巧是,当你有一个奇数时,在调用堆栈中存在偶数个否定。当你将布尔值否定偶数次时,它就像以前一样出现。当你有一个偶数时,你会有奇数的否定,结果会改变。

答案 1 :(得分:1)

  

当我遵循逻辑时,看起来无关紧要   你给“n”,它总是最终等于“0”并且总是结束   “假”。

您想要记住堆栈跟踪中有多少isOdd。例如:给定x = 2

isOdd(2) => !isEven(2) => !(isOdd(1)) => !(!isEven(1)) => !(!(isOdd(0))) => !(!(!isEven(0))) => !(!(!(true)))

答案 2 :(得分:0)

该代码适合我。我在Firefox和IE中尝试过它。

<html>
<head>
<script language="javascript">
function isOdd(x) {
    return !isEven(x);    
}

function isEven(x) {
    if(x===0) {
        return true;
    } else {
        return isOdd(x-1);
    }
}

alert(isOdd(6));

</script>

</head>
<body>

</body>
</html>

答案 3 :(得分:0)

递归解决方案有两个要求:基本案例和归纳步骤。在此示例中,基本情况是0是偶数。由于这是基本情况,所有调用最终会“降低”它的预期和正常。归纳步骤是即使数字大于奇数也是一个数字。但这并不是真正的归纳步骤,因为它以奇怪的方式定义了均匀性。所以还需要另一条规则,如果数字不均匀则数字是奇数。严格表明这种情况终止有点棘手,但Phillipp的堆栈图是一个很好的证明。