blocks|key|100749|text|直接递归:方法调用自身。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|100750|间接递归:方法调用其他方法，在多次调用之后，调用返回到第一个调用方法再次被调用的情况。|100751|大小写:它是任何递归函数的重要组成部分。它是递归方法停止调用自身从而结束递归的一个条件，即不再深入递归。基本上，如果您认为递归是一个yoyo，那么当递归处于其极端结束时，它就是基本情况。|100752|无限递归:它是一种永不结束的递归。基本上，它是一个没有大小写的递归函数。(一个不会回来的溜溜球，到处都是。)|100753|在这个链接上查看这些有趣的递归图像|offset|length|100754|entityMap|0|LINK|mutability|MUTABLE|url|https://www.quora.com/What-is-the-best-photo-that-explains-recursion^0|0|0|0|0|3|2|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$J|Y|K|Z|1|10]]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

Direct recursion: Method invokes itself.

Indirect recursion: Method invokes some other method and after many invocations, the call returns, to a situation where the first calling method is invoked again.

Base case: It is an important component of any recursion function. It is a condition for recursive method to stop calling itself and thus end the recursion i.e. stop going deeper in recursion. Basically, if you think of recursion as a yoyo then it is the base case when the recursion is at its extreme end. 

infinite recursion: It is a recursion which never ends. Basically it is a recursive function which does not have a base case. (a yo-yo which doesn't come back and goes all over the place.)

Checkout these interesting recursion images at this <a href="https://www.quora.com/What-is-the-best-photo-that-explains-recursion" rel="nofollow">link</a>

blocks|key|100759|text|直接递归是指方法调用自身时(如示例代码中所示)。间接递归是当方法a()调用方法b()时，方法本身(直接或间接)再次调用方法a()。|type|ordered-list-item|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|100760|无限递归是一种永不终止的递归。另一种说法是，无限递归是当基本情况不存在或从未遇到时。|100761|基大小写是一组参数值，它使方法在没有递归调用(直接或间接)的情况下返回。|100762|unstyled|entityMap^0|W|3|13|3|1P|3|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@]|D|@]|E|$]]|$1|J|3|-4|5|K|7|V|8|@]|D|@]|E|$]]]|L|$]]

<ol>
<li>Direct recursion is when a method calls itself (as in your example code). Indirect recursion is when method <code>a()</code> calls method <code>b()</code>, which itself (either directly or indirectly) calls method <code>a()</code> again.</li>
<li>Infinite recursion is recursion that never ends. Another way of putting it is that infinite recursion is when the base case either does not exist or is never encountered.</li>
<li>A base case is a set of argument values that causes the method to return without a recursive call (either direct or indirect).</li>
</ol>

blocks|key|857403|text|这是一种爬楼梯的算法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857404|climb:
++++if+you+are+at+the+top
++++++++stop
++++otherwise+
++++++++step+up+and+then+climb|code-block|syntax|javascript|857405|这表明您直接递归(爬升是一个步骤内攀爬)和基本情况(停止，如果你在顶部)。|857406|无限递归的两种情况：|857407|climb:
++++step+up+and+then+climb

climb:
++++if+you+are+at+the+top
++++++++stop
++++otherwise+
++++++++step+up+and+then+step+down+and+then+climb|857408|第一个没有大小写，第二个永远不会到达大小写：|857409|最后，间接递归：|857410|group+climb:
++++if+there's+no+one+in+the+group
++++++++stop
++++otherwise
++++++++step+up

step+up:
++++if+first+in+group+is+at+top
++++++++remove+them+from+the+group+then+group+climb
++++otherwise
++++++++step+up+first+in+group+then+group+climb|857411|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Here's an algorithm for climbing stairs

<pre><code>climb:
 if you are at the top
 stop
 otherwise 
 step up and then climb
</code></pre>

That shows you direct recursion (climb is a step inside climb) and base case (stop if you are at the top).

Two cases of infinite recursion:

<pre><code>climb:
 step up and then climb

climb:
 if you are at the top
 stop
 otherwise 
 step up and then step down and then climb
</code></pre>

The first has no base case and the second will never reach the base case:

Finally, indirect recursion:

<pre><code>group climb:
 if there's no one in the group
 stop
 otherwise
 step up

step up:
 if first in group is at top
 remove them from the group then group climb
 otherwise
 step up first in group then group climb
</code></pre>

What is direct recursions? What is infinite recursion?

What is a base case and why is it necessary/important? 

example code:

<pre><code>public static void indifferent(int x, int y) {

 if (x &lt;= y) {// base case
 System.out.print("!");
 }else {
 System.out.print(x);

 indifferent(x - 1, y + 2);

 System.out.print(y);
 }
}
</code></pre>

Some questions regarding recursion

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么是直接递归？什么是无限递归？什么是基本案例，为什么它是必要的/重要的？示例代码：public static void indifferent(int x, int y) { if (x <= y) {// base case System.out.print("!"); }else { ...

问关于递归的几个问题
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问关于递归的几个问题EN