Java 这个递归函数做什么？

这个函数做什么？你如何评价它

如何追踪它？如何理解递归方法

我只是不能理解递归，考试日期很快就要到了，我知道为了理解递归，我必须首先理解递归

但我就是写不出一个稍微复杂的递归方法，有谁能帮我用最简单的英语单词吗

public class BalancedStrings {

    public static void printBalanced(String prefix, int a, int b) {
        if (a > 0)
            printBalanced(prefix + "a", a - 1, b);
        if (b > 0)
            printBalanced(prefix + "b", a, b - 1);
        if (a == 0 && b == 0)
            System.out.println(prefix);
    }

    public static void printBalanced(int n) {
        if (n % 2 == 0) {
            printBalanced("", n / 2, n / 2);
        }
    }

    public static void main(String[] args) {
        printBalanced(4);
    }
}

---

对

printBalanced（）

的调用是递归调用。识别递归的方法是在函数调用自身时。使用树绘制时，最好理解递归：

树的分支将继续创建更多函数，直到满足结束条件，在本例中为

a==0&&b==0

。您提供的函数看起来像是在以递归方式打印字符串“prefix”，该字符串由指定数量的“a”和“b”字符连接而成。当变量

a

和

b

达到

0

时，递归停止，并使用

System.out.println（前缀）打印结果

在主函数中，您将整数4传递给
printbeated（int n）
，调用
printbeated（字符串前缀，int a，int b）
，参数如下：
printbeated（“，2,2”）

总的结果是前缀与平衡数量的a和b连接起来
对
printBalanced（）
的调用是递归调用。识别递归的方法是在函数调用自身时。使用树绘制时，最好理解递归：


树的分支将继续创建更多函数，直到满足结束条件，在本例中为
a==0&&b==0
。您提供的函数看起来像是在以递归方式打印字符串“prefix”，该字符串由指定数量的“a”和“b”字符连接而成。当变量
a
和
b
达到
0
时，递归停止，并使用
System.out.println（前缀）打印结果

在主函数中，您将整数4传递给
printbeated（int n）
，调用
printbeated（字符串前缀，int a，int b）
，参数如下：
printbeated（“，2,2”）

总的结果是前缀与平衡数量的a和b连接起来
您的停止条件是

a == 0 & b == 0

在满足此条件之前，递归调用函数并降低a和b，直到它们都为0

尝试在printBalanced（）中设置一些断点，以便查看其工作原理。
您的停止条件是

a == 0 & b == 0

在满足此条件之前，递归调用函数并降低a和b，直到它们都为0

尝试在printBalanced（）中设置一些断点，以便查看它的工作原理。
从最基本的计算机科学意义上讲，递归是一个调用自身的函数。
递归的一些实际用途

树遍历

图形

词法分析/解析

排序

递归的基本思想是将原始问题分解成更小（更容易解决）的实例，求解这些更小的实例（通常再次使用相同的算法），然后将它们重新组合成最终的解决方案

例如，考虑下面的C代码，计算一个数< /P>的阶乘
function factorial(int n)
{
  int fact = 1;
  for( int i = 2; i <= n; i++)
  {
    fact = fact * i;
  }
  return fact;
}

函数阶乘（int n）
{
int-fact=1；
对于（inti=2；i，在最基本的计算机科学意义上，递归是一个调用自身的函数。
递归的一些实际用途

树遍历

图形

词法分析/解析

排序

递归的基本思想是将原始问题分解成更小（更容易解决）的实例，求解这些更小的实例（通常再次使用相同的算法），然后将它们重新组合成最终的解决方案

例如，考虑下面的C代码，计算一个数< /P>的阶乘
function factorial(int n)
{
  int fact = 1;
  for( int i = 2; i <= n; i++)
  {
    fact = fact * i;
  }
  return fact;
}

函数阶乘（int n）
{
int-fact=1；
对于（int i=2；i它可以帮助您查看递归，方法是在每次调用printBalanced之前放置print语句，并将print语句作为每个printBalanced方法定义的第一行。请参见以下内容：

public class BalancedStrings {

    public static void printBalanced(String prefix, int a, int b) {
        System.out.println( "printBalanced called prefix = " + prefix + " a = " + a + " b = " + b );
        if (a > 0) {
            System.out.println( "printBalanced calling printBalanced with prefix = " + prefix + " a-1 = " + (a-1) + " b = " + b );
            printBalanced(prefix + "a", a - 1, b);
        }
        if (b > 0) {
            System.out.println( "printBalanced calling printBalanced with prefix = " + prefix + " a = " + a + " b-1 = " + (b-1) );
            printBalanced(prefix + "b", a, b - 1);
        }
        if (a == 0 && b == 0)
            System.out.println(prefix);
    }

    public static void printBalanced(int n) {
        System.out.println( "printBalanced called n = " + n );
        if (n % 2 == 0) {
            printBalanced("", n / 2, n / 2);
        }
    }

    public static void main(String[] args) {
        printBalanced(4);
    }
}

此外，printBalanced也被称为重载方法，因为它有两个“方法签名”，这基本上意味着它被定义了不止一次，并且每个方法定义都有一组不同的变量传递给该方法

基本上，printBalanced会一直调用自己，直到变量a和b减为零。然后它会打印出不断累积的结果前缀

此外，所有这些神奇的事情都可能发生，因为每个方法调用都会将前缀a和b的当前状态推送到调用堆栈上。然后，当方法最终返回而不进行递归调用时，堆栈就会展开

我希望这会有帮助！递归可能很难理解。您也可以通过自己玩电脑手动跟踪调用，并通过在纸上写下将被推到调用堆栈上的前缀、a和b的值来跟踪方法的执行

以下是程序的输出，包括跟踪打印：

C:\Users\>java BalancedStrings
printBalanced called n = 4
printBalanced called prefix =  a = 2 b = 2
printBalanced calling printBalanced with prefix =  a-1 = 1 b = 2
printBalanced called prefix = a a = 1 b = 2
printBalanced calling printBalanced with prefix = a a-1 = 0 b = 2
printBalanced called prefix = aa a = 0 b = 2
printBalanced calling printBalanced with prefix = aa a = 0 b-1 = 1
printBalanced called prefix = aab a = 0 b = 1
printBalanced calling printBalanced with prefix = aab a = 0 b-1 = 0
printBalanced called prefix = aabb a = 0 b = 0
aabb
printBalanced calling printBalanced with prefix = a a = 1 b-1 = 1
printBalanced called prefix = ab a = 1 b = 1
printBalanced calling printBalanced with prefix = ab a-1 = 0 b = 1
printBalanced called prefix = aba a = 0 b = 1
printBalanced calling printBalanced with prefix = aba a = 0 b-1 = 0
printBalanced called prefix = abab a = 0 b = 0
abab
printBalanced calling printBalanced with prefix = ab a = 1 b-1 = 0
printBalanced called prefix = abb a = 1 b = 0
printBalanced calling printBalanced with prefix = abb a-1 = 0 b = 0
printBalanced called prefix = abba a = 0 b = 0
abba
printBalanced calling printBalanced with prefix =  a = 2 b-1 = 1
printBalanced called prefix = b a = 2 b = 1
printBalanced calling printBalanced with prefix = b a-1 = 1 b = 1
printBalanced called prefix = ba a = 1 b = 1
printBalanced calling printBalanced with prefix = ba a-1 = 0 b = 1
printBalanced called prefix = baa a = 0 b = 1
printBalanced calling printBalanced with prefix = baa a = 0 b-1 = 0
printBalanced called prefix = baab a = 0 b = 0
baab
printBalanced calling printBalanced with prefix = ba a = 1 b-1 = 0
printBalanced called prefix = bab a = 1 b = 0
printBalanced calling printBalanced with prefix = bab a-1 = 0 b = 0
printBalanced called prefix = baba a = 0 b = 0
baba
printBalanced calling printBalanced with prefix = b a = 2 b-1 = 0
printBalanced called prefix = bb a = 2 b = 0
printBalanced calling printBalanced with prefix = bb a-1 = 1 b = 0
printBalanced called prefix = bba a = 1 b = 0
printBalanced calling printBalanced with prefix = bba a-1 = 0 b = 0
printBalanced called prefix = bbaa a = 0 b = 0
bbaa

通过在每次调用printBalanced之前放置print语句，以及将print语句作为每个printBalanced方法定义的第一行，可以帮助您查看递归。请参见以下内容：

public class BalancedStrings {

    public static void printBalanced(String prefix, int a, int b) {
        System.out.println( "printBalanced called prefix = " + prefix + " a = " + a + " b = " + b );
        if (a > 0) {
            System.out.println( "printBalanced calling printBalanced with prefix = " + prefix + " a-1 = " + (a-1) + " b = " + b );
            printBalanced(prefix + "a", a - 1, b);
        }
        if (b > 0) {
            System.out.println( "printBalanced calling printBalanced with prefix = " + prefix + " a = " + a + " b-1 = " + (b-1) );
            printBalanced(prefix + "b", a, b - 1);
        }
        if (a == 0 && b == 0)
            System.out.println(prefix);
    }

    public static void printBalanced(int n) {
        System.out.println( "printBalanced called n = " + n );
        if (n % 2 == 0) {
            printBalanced("", n / 2, n / 2);
        }
    }

    public static void main(String[] args) {
        printBalanced(4);
    }
}

此外，printBalanced也被称为重载方法，因为它有两个“方法签名”，这基本上意味着它被定义了不止一次，并且每个方法定义都有一组不同的变量传递给该方法

基本上，printBalanced会一直调用自己，直到变量a和b减为零