编写一个以数组和数组大小为参数的递归函数，打印该数组，不返回任何内容

了解使用以下函数调用该函数会发生什么情况: int main(void){int arr [] = {1，2，3}，nelem = sizeof arr/sizeof * arr;prnarray(arr，nelem);} 最简单的方法就是用 nelem 的值创建一个表.例如: 卷入 nelem == 3 :来自 main() 的初始调用 prnarray(arr，nelem); 然后在第一个函数调用中，-nelem 将 nelem 的值减小 1 ，然后再由 if求值.(). nelem == 2 :在 if()语句之后，执行路径为: 如果(--nelem> 0)/*缠绕(两次)直到nelem == 0 */prnarray(arr，nelem); nelem == 1 :然后在-nelem ， nelem == 1 之后的下一个调用中: 如果(--nelem> 0)/*缠绕(两次)直到nelem == 0 */prnarray(arr，nelem); nelem == 0 然后在下一个调用(最后一个递归调用)中命中基本情况，因为在-nelem ， nelem == 0 之后，测试条件失败，并且执行路径继续: printf(％d \ n"，arr [nelem])；/*展开输出元素*/ (此处打印第一个元素"1") 放卷 现在会发生什么??我们已经到达函数的末尾了? 执行将在导致这一点的函数调用之后执行.那是什么?导致这一点的函数调用是对 prnarray()的递归调用，这导致我们进入了此函数的主体.(每个函数调用在后台将基本指针地址保存在函数堆栈中，因此当函数执行完成时，它知道在调用函数中从何处恢复执行.) nelem == 1 因此，当执行 nelem == 0 的函数的执行结束时，我们将从函数调用中 nelem == 1 结束的地方开始-从先前对 prnarray()的调用返回如果我们查看整个函数，其中函数入口上的 nelem == 1 ( nelem == 2 )，我们在上一次调用 prnarray()后在接收区中接听了 void prnarray(int * arr，int nelem){如果(--nelem> 0)/*缠绕(两次)直到nelem == 0 */+< ----- prnarray(arr，nelem);|+-> printf(％d \ n"，arr [nelem])；/*展开输出元素*/} (此处显示值为 2 的第二个元素)因此，在先前的 prnarray()展开后，执行路径中剩下的唯一命令是 printf()和第二个元素 2 将被打印，函数结束并再次展开，结果相同: nelem == 2 (在该函数进入时为 3 )执行路径为 printf()函数 printf(％d \ n"，arr [nelem])；/*展开输出元素*/ (第三个也是最后一个值为 3 的元素在这里打印) nelem == 3 是从 main()进行的原始函数调用，因此现在展开已完成，并且在调用以下代码后，程序在 main()中执行: prnarray(arr，nelem); 程序结束....仔细研究递归函数程序的执行路径并创建表是一种熟悉递归函数调用的好方法.(即使您对它们感到满意，当您使用函数在函数主体中进行两个或多个递归调用时，您也将回到创建表并跟踪执行路径的方式).程序执行路径中的分支带有多个递归调用，这些递归调用分别递归函数，这些分支似乎将以指数复杂度扩展.有了这些信息，您现在应该可以调整功能并知道在哪里寻找结果.如果您还有其他问题，请告诉我.I'm very new to programming (since August) and recursion is my Achilles heel. The question is this: Write a recursive function printArray() that takes an array and the size of the array as arguments, prints the array, and returns nothing. The function should stop processing and return when it receives an array of size zero.So the function alone would be something like this?:void printArray(int arr[], int SIZE) { int counter = 0; if (SIZE == 0) { return -1; } else if (SIZE > 0) { printf("%d", arr[counter]); counter++; printArray(arr, SIZE - 1); } puts("");}I'm honestly grasping at straws here so excuse the facepalms I may cause as I am looking at countless of codes and trying to piece some of them together and see if it can help me in any way.And when implementing it into main(), should I initialize additional variables? Mainly a new array seeing as anything I place in arr[] within the function parameter is out of scope. 解决方案 Recursive functions take a bit of thinking though to trace the program execution-path as the recursive calls "wind-in", and then "unwinds" after the recursion is broken and each recursive function call completes. For example take the simple case of:void prnarray (int *arr, int nelem){ if (--nelem > 0) /* wind-in (twice) until nelem == 0 */ prnarray (arr, nelem); printf ("%d\n", arr[nelem]); /* unwind outputting elements */}(where nelem is the number-of-elements in the array, technically not its "size" [unless it is an array of char])Trace what happens if that function was called with:int main (void) { int arr[] = { 1, 2, 3 }, nelem = sizeof arr/sizeof *arr; prnarray (arr, nelem);}The easiest way is just make a table with the value of nelem. For example:Winding-Innelem == 3:initial call from main() prnarray (arr, nelem);then in the first function call, --nelem reduces the value of nelem by 1 before being evaluated by the if().nelem == 2:following the if() statement, the execution path is: if (--nelem > 0) /* wind-in (twice) until nelem == 0 */ prnarray (arr, nelem);nelem == 1:then in the next call after --nelem, nelem == 1: if (--nelem > 0) /* wind-in (twice) until nelem == 0 */ prnarray (arr, nelem);nelem == 0then in the next call, the last recursive call, the base case is hit because after --nelem, nelem == 0 so the test condition fails and the execution-path continues with: printf ("%d\n", arr[nelem]); /* unwind outputting elements */(the first element '1' is printed here)UnwindingWhat happens now?? We have reached the end of the function??Execution will pick up after the function call that lead to this point. Where is that? The function call that lead to this point is the recursive call to prnarray() that lead to us being in the body of this function.(under the hood each function call saves the base-pointer address on the function stack so when the function execution is done it knows where to resume execution in the calling function.)nelem == 1So when execution of the function where nelem == 0 ends, we pick up where we left off in the function call where nelem == 1 -- which is returning from the prior call to prnarray() If we look at the whole function where nelem == 1 (nelem == 2 on function entry) we pick up after the previous call to prnarray() one-level up in the recusrion:void prnarray (int *arr, int nelem){ if (--nelem > 0) /* wind-in (twice) until nelem == 0 */+<----- prnarray (arr, nelem);|+-->printf ("%d\n", arr[nelem]); /* unwind outputting elements */}(the second element with value 2 is printed here)So after the prior prnarray() unwinds, the only command left in the execution-path is printf() and the second element 2 is printed and the function ends and unwinds again with the same result:nelem == 2(3 on entry into the function) the execution-path is the printf() function printf ("%d\n", arr[nelem]); /* unwind outputting elements */(the third and final element with value 3 is printed here)nelem == 3was the original function call from main(), so now unwinding is complete and program execution picks up in main() after the call to: prnarray (arr, nelem);and the program ends....Thinking through the recursive function program execution-path and making a table is a good way to become comfortable with recursive function calls. (even if you are comfortable with them, when you get to functions making two or more recursive calls within the body of the function -- you will be right back to making a table and tracing the execution path). The branches in the program execution-path with multiple recursive calls to separate recursive functions will seem to expand with exponential complexity.With this information, you should now be able to tweak your function and know where to look for the result to take place. Let me know if you have further questions. 这篇关于编写一个以数组和数组大小为参数的递归函数，打印该数组，不返回任何内容的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！ 上岸，阿里云！