user-0 提问: 大神看下c语言递归问题

回复:
user: user-1

user: user-2
content: 引用 13 楼 qq_36639412 的回复:引用 12 楼 cfjtaishan 的回复:[quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？

user: user-2
content: 引用 21 楼 qq_36639412 的回复:引用 20 楼 qq_36639412 的回复:[quote=引用 19 楼 cfjtaishan 的回复:] [quote=引用 18 楼 qq_36639412 的回复:] [quote=引用 17 楼 cfjtaishan 的回复:] [quote=引用 13 楼 qq_36639412 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote]  引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote] 是一样的啊，只是判断的是个整数，第一个程序是字符，那第二个怎么会输出不满足的条件值呢[/quote] 嗯，条件不一样，你输入#是可以输出#的，因为#不是5；你的判断条件是只要输入的不是5，都会将输入的内容倒序输出。[/quote] 嗯，但是输入12345，输出54321，这正确么？5不是条件嘛[/quote] 哦，知道问题了，if那里执行了空语句[/quote]

user: user-0
content: 引用 20 楼 qq_36639412 的回复:引用 19 楼 cfjtaishan 的回复:[quote=引用 18 楼 qq_36639412 的回复:] [quote=引用 17 楼 cfjtaishan 的回复:] [quote=引用 13 楼 qq_36639412 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote]  引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote] 是一样的啊，只是判断的是个整数，第一个程序是字符，那第二个怎么会输出不满足的条件值呢[/quote] 嗯，条件不一样，你输入#是可以输出#的，因为#不是5；你的判断条件是只要输入的不是5，都会将输入的内容倒序输出。[/quote] 嗯，但是输入12345，输出54321，这正确么？5不是条件嘛[/quote] 哦，知道问题了，if那里执行了空语句

user: user-0
content: 引用 19 楼 cfjtaishan 的回复:引用 18 楼 qq_36639412 的回复:[quote=引用 17 楼 cfjtaishan 的回复:] [quote=引用 13 楼 qq_36639412 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote]  引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote] 是一样的啊，只是判断的是个整数，第一个程序是字符，那第二个怎么会输出不满足的条件值呢[/quote] 嗯，条件不一样，你输入#是可以输出#的，因为#不是5；你的判断条件是只要输入的不是5，都会将输入的内容倒序输出。[/quote] 嗯，但是输入12345，输出54321，这正确么？5不是条件嘛

user: user-2
content: 引用 18 楼 qq_36639412 的回复:引用 17 楼 cfjtaishan 的回复:[quote=引用 13 楼 qq_36639412 的回复:] [quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote]  引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote] 是一样的啊，只是判断的是个整数，第一个程序是字符，那第二个怎么会输出不满足的条件值呢[/quote] 嗯，条件不一样，你输入#是可以输出#的，因为#不是5；你的判断条件是只要输入的不是5，都会将输入的内容倒序输出。

user: user-0
content: 引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote]  引用 17 楼 cfjtaishan 的回复:引用 13 楼 qq_36639412 的回复:[quote=引用 12 楼 cfjtaishan 的回复:] [quote=引用 10 楼 qq_36639412 的回复:] [quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }  [/quote] 这是第二个问题了，我们一直在讨论你的第一个问题，第二个程序很明显和第一个程序差距很大呢，判断条件都已经变了，怎么可能输入和输出都一样呢？[/quote] 是一样的啊，只是判断的是个整数，第一个程序是字符，那第二个怎么会输出不满足的条件值呢

user: user-3
content: 因为item函数中，递归调用是在printf前面，所以会一直递归到最里层，才开始输出，所以是逆序的

user: user-0
content: 引用 3 楼 cfjtaishan 的回复:注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？

user: user-0
content: 引用 2 楼 u012807807 的回复:你的输出是在递归调用之后才有的，所以如果不输入#就一直递归下去，每一层都在递归的那个函数停下来进入更深层，直到出现了#不再调用，程序能够退出，这时候才从里到外层层执行你的那个输出函数，自然就是逆序输出了。 引用 2 楼 u012807807 的回复:你的输出是在递归调用之后才有的，所以如果不输入#就一直递归下去，每一层都在递归的那个函数停下来进入更深层，直到出现了#不再调用，程序能够退出，这时候才从里到外层层执行你的那个输出函数，自然就是逆序输出了。 第二个if(!='#')怎么理解，是不等于#了就返回上一层的函数输入？

user: user-1
content: “给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

user: user-2
content: 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。

user: user-4
content: 引用 15 楼 qq_36639412 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。 会输出不满足条件的值 #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     } [/quote] 你最初的程序不会输出#，这个程序应该会进入死循环，最后栈溢出然后挂掉吧，你只要输入的不是5，则会一直不停调用在Z（0）,再也退不出来了

user: user-0
content: 引用 3 楼 cfjtaishan 的回复:注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。 会输出不满足条件的值 #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }

user: user-0
content: 引用 2 楼 u012807807 的回复:你的输出是在递归调用之后才有的，所以如果不输入#就一直递归下去，每一层都在递归的那个函数停下来进入更深层，直到出现了#不再调用，程序能够退出，这时候才从里到外层层执行你的那个输出函数，自然就是逆序输出了。 怎么不满足条件的也会输出 #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }

user: user-0
content: 引用 12 楼 cfjtaishan 的回复:引用 10 楼 qq_36639412 的回复:[quote=引用 8 楼 cfjtaishan 的回复:] [quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.[/quote] 你看下这段代码怎么会输出， #include<iostream> #include<cstdlib> using namespace std; void Z(int n) {            cin>>n;      if(n!=5)      Z(0);      if(n!=5);     cout<<n<<endl;   system("pause");         } int main() {     Z(0);      return 0;     }

user: user-2
content: 引用 10 楼 qq_36639412 的回复:引用 8 楼 cfjtaishan 的回复:[quote=引用 6 楼 qq_36639412 的回复:] [quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？[/quote] 你确定输出了#? 我试了一下你的程序怎么没有输出#.

user: user-0
content: 引用 9 楼 u012807807 的回复:[quote=引用 5 楼 qq_36639412 的回复:] [quote=引用 2 楼 u012807807 的回复:] 你的输出是在递归调用之后才有的，所以如果不输入#就一直递归下去，每一层都在递归的那个函数停下来进入更深层，直到出现了#不再调用，程序能够退出，这时候才从里到外层层执行你的那个输出函数，自然就是逆序输出了。 第二个if(!='#')怎么理解，是不等于#了就返回上一层的函数输入？ [/quote] 六楼已经说的很清楚了应该，你的第二个判断都是暂时不执行的，因为已经进入了更深层次的函数，只有等函数返回了 才接着进行第二个if判断，这时的i都还存在栈里面，倒着一个个吐出来[/quote] 那怎么#还是会输出

user: user-0
content: 引用 8 楼 cfjtaishan 的回复:引用 6 楼 qq_36639412 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] 注意递归是不停的申请函数栈空间，根据先进后出的栈原理，它的输出自然是逆序的。关键是两个if是怎么判断的？条件都是一样的，第一个是不成立就不调用自己，那么第二if也是一样的判断条件呢，是不是可以这样理解，如果输入#了就不调用，返回上一次调用的输入判断满不满足条件？ 如果输入的不是#,函数会继续进入新的函数栈，然后重新开始执行，等待输入，然后判断输入的字符是否为#,如果遇到了#，那么该函数栈继续向后执行，输出最后一个输入的字符，最后一个是#，所以不输出。从最后一个函数栈上退出，返回倒数第二次输入的函数栈，执行余下的语句：   if(i!='#')       printf("%c\n",i);   system("pause"); 倒数第二次输入的不是#，所以把倒数第二次输入的字符输出，然后进入倒数第三次的函数栈，执行：   if(i!='#')       printf("%c\n",i);       system("pause"); 这样输出倒数第三次输入的字符。依次类推，这就是递归嘛[/quote] 嗯，那为什么#还是会输出呢？

user: user-4
content: 引用 5 楼 qq_36639412 的回复:[quote=引用 2 楼 u012807807 的回复:] 你的输出是在递归调用之后才有的，所以如果不输入#就一直递归下去，每一层都在递归的那个函数停下来进入更深层，直到出现了#不再调用，程序能够退出，这时候才从里到外层层执行你的那个输出函数，自然就是逆序输出了。 第二个if(!='#')怎么理解，是不等于#了就返回上一层的函数输入？ [/quote] 六楼已经说的很清楚了应该，你的第二个判断都是暂时不执行的，因为已经进入了更深层次的函数，只有等函数返回了 才接着进行第二个if判断，这时的i都还存在栈里面，倒着一个个吐出来