相关疑难解决方法(0)

可能重复:
递归还是迭代？

迭代是人,是递归神圣. - L. Peter Deutsch

为什么人们喜欢递归而不是迭代,甚至可以称之为神圣,如引用中所示？它似乎过度炒作了.据我所知,递归代码更难以掌握,因此维护.此外,如果编译器未进行优化,则会冒着堆栈溢出的风险.

这一个重复.

你会用什么来填充Flex/AS3中数字左边的零？

是否有相同printf或者NumberFormat这样做？

我正在寻找这个或类似的最好的实现:

public function zeroPad(number:int, width:int):String {
    // number = 46, width = 4 would return "0046"
}

我在接受采访时被问及解决问题检查pallindrome的有效方法.

现在我可以做两件事:

1. 从i = 0开始到i = n/2并且将第i个和第n个字符比较为相等.
2. 我可以使用递归来检查第一个和最后一个是否相同,并且字符串的其余部分是pallindrome.

第二个是递归的.我的问题是算法的递归和非递归版本的空间复杂度有什么不同？

我已经在C#中实现了一个四叉树,并且遇到了一个奇怪的现象,其中递归似乎比迭代更好,尽管它看起来应该是相反的.

我的节点看起来像这样:

class QuadNode
{
    private QuadNode topLeft;
    private QuadNode topRight;
    private QuadNode bottomRight;
    private QuadNode bottomLeft;
    // other fields...
}

为了遍历树,我使用了以下递归方法,我在根节点上调用:

Traverse()
{
    // visit 'this'

    if (topLeft != null)
        topLeft.Traverse();
    if (topRight != null)
        topRight.Traverse();
    if (bottomRight != null)
        bottomRight.Traverse();
    if (bottomLeft != null)
        bottomLeft.Traverse();
}

主要是出于兴趣,我试图创建一个遍历树的迭代方法.

添加以下字段到每个节点:private QuadNode next,当我创建树我使用队列,连接进行广度优先遍历next各节点的字段中线上的下一个节点.基本上我从树的节点创建了一个单链表.
此时,我可以使用以下方法遍历树:

Traverse()
{
    QuadNode node = this;
    while (node != null)
    {
        // visit node

        node = node.next;
    }
}

测试每个方法的表现后,我很惊讶地得知,迭代版本是一致且明显比递归一个慢.我已经在巨大的树木和小树上进行了测试,递归方法总是更快.(我用了一个Stopwatch标杆)
,我证实,这两种方法成功地遍历整个树和迭代版本只访问每个节点恰好一次按计划进行 …

你好android/Java开发者,

当一个函数调用一个函数并且该函数调用另一个函数时,有多少调用(堆栈长度)会让我进入堆栈流量？有一般的经验法则吗？

我问的原因是因为我现在对于我的5玩家纸牌游戏来说效率更高(设计明智)

解决方案1:

for(int i=0;i<100;i++){
         p1.play();
         p2.play();
         p3.play();
         p4.play();
}

解决方案2:

   p1.play();    //where p1.play() calls p2.play() and so on until p4 calls p1 again.   
                 // this will go on for 100 times

我更喜欢解决方案2,所以如果发生崩溃,我可以看到从i = 0的p1到i = 100的p4的所有函数调用

但是对于解决方案1,堆栈要短得多但是当发生崩溃时我会在循环的开头看到一个被调用的函数play(),其中发生了崩溃

你有什么建议？我知道它有点2个问题,但它们非常相关

谢谢你们

在我的大学里,我被要求为Fibonacci系列写一个JAVA程序.我使用递归来编写该程序.

但是,助理讲师说我的算法效率不高,并要求我分析.他补充说,按照惯例,迭代适用于该程序而不是递归.

如何分析我们的算法？如何在迭代和递归中检查空间和时间复杂度？就在这时,我发现这些东西和程序的正确性一样重要.

我一直在阅读塞奇威克和韦恩的"算法,第四版".本书介绍了两种使用合并排序的方法.使用标准的自顶向下递归合并排序或自底向上合并排序.

是否存在自下而上合并排序比自上而下版本更受欢迎的情况？

在我的最后一个任务中,我得到了停靠点,因为在没有必要的情况下使用递归.在你不需要的地方使用递归是不好的做法吗？

例如,这个Python代码块可以用两种方式编写:

def test():
    if(foo() == 'success!'):
        print(True)
    else:
        test()

要么

def test():
    while(True):
        if(foo() == 'success!'):
            print(True)
            break

一个天生就好比另一个好吗？(表现方面还是实践方面)？

1. 我很难找到递归的工作原理.一些教科书说"递归就是一个函数一次又一次地调用自己,直到满足一些基本条件".

2. 有些书说"递归就是一个函数一次又一次地调用另一个函数,直到满足一些基本条件 ".

3. 这是真的吗？如果两者都是真的,我们可以将下面给出的例子视为递归吗？如果否,那么在性能方面哪个更好,

   下面的代码或递归？

    def Function1()
    {
        /* do something */
    }

    def Function2()
    {
        for(i=0; i<=10; i++)
        {
             call Function1()
        }
    }

在开始之前,我已经无数次地使用谷歌,希望能够在返回类型时搜索递归有效的简单而简单的解释.但我想我并不像我想的那么聪明,因为我仍然无法理解它.

以下面的代码片段(在java中)为例

public static int recursion(int num)
{  
 int result;   

if (num == 1)
    result = 1;

else           
     result = recursion(num - 1) + num; 

return result;

} 

我从教授讲座幻灯片中抓住了这段代码,他说这将返回1 + 2 + 3 + ... + num.

我只需要有人来解释这个过程在我提供的方法中是如何工作的.也许一步一步的方法可以帮助我理解递归的工作原理.

通常我会按照此行进行验证:

public static void Menu()
{
    Scanner keyboard = new Scanner(System.in);
    if (!keyboard.hasNextInt())
    {
        System.out.println("Incorrect input, try again");
        Menu();
    }  
    else
    {
        // switch statement etc
    }
}

我只是想知道这是一种不好的做法吗？如果是这样的话,为什么以及除了使用递归之外还有什么更好的方法.我已经使用递归来获得数字和其他一些东西的力量,所以我理解它的想法.