AP CSA递归题目讲解（附加递归树）

题目

10. Consider the following method.
    /** Precondition: 0 < numVals <= nums.length */
    public static int mystery(int[] nums, int v, int numVals)
    {
        int k = 0;
        if (v == nums[numVals - 1])
        {
            k = 1;
        }
        if (numVals == 1)
        {
            return k;
        }
        else
        {
            return k + mystery(nums, v, numVals - 1);
        }
    }
Which of the following best describes what the call mystery(numbers, val, numbers.length) does? You may assume that variables numbers and val have been declared and initialized.
A Returns 1 if the last element in numbers is equal to val; otherwise, returns 0
B Returns the index of the last element in numbers that is equal to val
C Returns the number of elements in numbers that are equal to val
D Returns the number of elements in numbers that are not equal to val
E Returns the maximum number of adjacent elements that are not equal to val

答案

C

讲解

1. 函数逻辑分析
   • 函数mystery是一个递归函数。它接收一个整数数组nums，一个整数v，以及一个表示数组中有效元素数量的numVals。
   • 首先定义了一个变量k = 0 ，然后检查v是否等于数组中最后一个元素nums[numVals - 1] ，如果相等，将k赋值为1 。
   • 接着检查numVals是否等于1 ，如果是，直接返回k 。
   • 如果numVals大于1 ，则进行递归调用mystery(nums, v, numVals - 1) ，并将当前的k与递归调用的结果相加后返回。这意味着函数会不断地检查数组中的元素，从后往前，只要元素等于v ，就会在递归过程中累加k的值。
2. 选项分析
   • 选项A：函数不是只判断最后一个元素是否等于val ，而是遍历数组中多个元素，所以A错误。
   • 选项B：函数没有返回元素的索引，所以B错误。
   • 选项C：函数通过递归累加等于v（即val ）的元素个数，C正确。
   • 选项D：函数统计的是等于val的元素个数，不是不等于val的元素个数，所以D错误。
   • 选项E：函数没有统计相邻且不等于val的元素个数，所以E错误。

讲解：
这个方法mystery是一个递归函数，它检查数组nums中是否存在值v，并统计v在数组中出现的次数。

递归过程：

1. 基本情况：

   • 如果numVals == 1，这意味着我们只查看数组的最后一个元素。
   • 如果v等于nums[numVals - 1]，那么k被设置为1（表示有一个v的出现）。
   • 如果v不等于nums[numVals - 1]，那么k保持为0（表示没有v的出现）。
   • 函数返回k。

2. 递归情况：

   • 如果numVals > 1，函数检查v是否等于nums[numVals - 1]。
   • 如果v等于nums[numVals - 1]，那么k被设置为1。
   • 函数然后调用自身，numVals - 1（即，它移动到数组中的下一个元素）。
   • 递归调用的结果被加到k。

递归树：

假设numbers = [3, 5, 3, 7, 3]，val = 3。我们将调用mystery(numbers, val, numbers.length)。

mystery([3, 5, 3, 7, 3], 3, 5)
  |
  +-- k = 0 (因为 3 != 3)
  +-- mystery([3, 5, 3, 7, 3], 3, 4)
        |
        +-- k = 0 (因为 3 != 7)
        +-- mystery([3, 5, 3, 7, 3], 3, 3)
              |
              +-- k = 1 (因为 3 == 3)
              +-- mystery([3, 5, 3, 7, 3], 3, 2)
                    |
                    +-- k = 0 (因为 3 != 3)
                    +-- mystery([3, 5, 3, 7, 3], 3, 1)
                          |
                          +-- k = 1 (因为 3 == 3)
                          +-- mystery([3, 5, 3, 7, 3], 3, 0)
                                |
                                +-- 基本情况：numVals == 1，返回 k（即 1）

计算：

• 基本情况返回1（对于最后一个元素）。
• 下一个层级加0（因为3 != 3）。
• 下一个层级加1（因为3 == 3）。
• 下一个层级加0（因为3 != 7）。
• 下一个层级加1（因为3 == 3）。

所以，最终结果是1 + 0 + 1 + 0 + 1 = 3。

结论：

方法mystery(numbers, val, numbers.length)返回numbers中等于val的元素数量。

答案：
C 返回numbers中等于val的元素数量