1、while循环 while语句的一般形式为：while(表达式)语句。其中表达式是循环条件，语句为循环体。while语句中的表达式一般是关系表达或逻辑表达式，只要表达式的.
 
for语句循环1 for语句一般形式中的各表达式可以省略，但是分号间隔符不能少。需要注意省略表达式1之前要给循环变量赋初值。2 如省略去表达式2或者3则将造成无限循.
 
循环变量，循环条件，循环体。 关键是这三部分的作用是什么？以及缺少循环。
 
1.用while语句实现循环 基础结构： while(循环条件表达式) { 循环体语句} 只要当循环条件表达式为真，就执行循环体语句。2.用do.while语句实现循环 基础结构： do {循.
 
我想知道改程序是不是死循环呢？？求大神解答
 
输入 detax若大于1 则 不执行for 若小于等于1则死循环 按上下文意思 应该是 for循环 缺少 {} 包含整个循环块
 
分为两种 分别是什么 清举例说明
 
一种是for()循环，例如：for (i=0;i<10;i++) printf(＂%d\n＂,i)； 另一种是while()循环，有两种形式：while(i<10) printf(＂%d＂,i)； 和 do { printf(＂%d＂,i); }while (i--);
 
用for循环结构求1!+2!+3！+……+10！ 请各位大神赐教
 
#include int main(){ int n=10； //可更改 int i, j, s, t; s =0; for (i=1; i t = 1; for (j=1; j t *= j; s += t; } printf(＂%d\n＂, s); return 0; }
 
1.d do-while构成的循环，当while中的表达式值为零时结束循环，非零时继续循环，while循环也是一样2.c 外循环执行从0到5共6次，内循环执行从0到3共4次，一共执行6*4.
 
do……while ：先循环，在判断 while ：先判断后循环 for：一般可以代替上面两个
 
在学完这三个循环后，应明确它们的异同点：用while和do…while循环时，循环变量的初始化的操作应在循环体之前，而for循环一般在语句1中进行的；while 循环和for循环.
 
c)满足条件时反复执行循环体 d)以上都对 选d结果错了
 
就我看书理解，c语言的典型结构有顺序结构，选择结构，循环结构。顺序结构就不用我说了，就是按照语句次序进行语句编译，选择结构是针对满足一定的条件而执行相.
 
当循环：while(条件){}/*条件为真时，执行括号语句，有可能执行零次*/ 直到循环：do{}while(条件)/*执行循环，直到条件为真结束，至少执行一次*/ for循环：for(初始.
 
不止三种for、while、do.while这三种是最常用的另外还有if.goto等循环结构
 
具体要什么样的程序？ 循环有几种模式：for 语句 while语句 goto语句 do while语句 for(初始化；判断条件；趋向的值) //解释：趋向值也就是一个限制的值，不写这个值会.
 
是的。C语言为结构化的语言，C语言有三种结构：顺序结构、选择结构、循环结构。循环结构又包含当型循环和直到型循环：1、当型循环：先判断，后执行。最少执行0.
 
常见就三种：for循环，while循环，do…while循环当然，也可以用goto做伪循环还有用函数实现循环：单一函数调用自己实现的循环叫做：递归函数，两个或者多个函数首.
 
编写程序，打印以下图形： * *** ***** ******* ***** *** * 以上图形是这样子的： .
 
#include void main() { int n,i,j,k; scanf(＂%d＂,&n); for(i=1;i<=n;i++) { for(j=1;j<=n-i;j++) printf(＂ ＂); for(k=1;k<=2*i-1;k++) printf(＂*＂); printf(＂\n＂); } }
 
1. 应用灵活，不符合“单入口单出口原则”，这是使用continue和break的原因2. 功能强大，实际上一个for循环就可以解决所有循环问题3. 没有真正的“直到型循环”，所.
 
一#include main(){int a,b;scanf(＂%d＂,&a);if (a>0) b=1;else if (a<0)b=-1elseb=0;printf(＂1大于零，0等于0,-1小于0:%d＂,b)}二#include main(){int a,b,c,d;.
 
#include void main() { int n=1; float temp; float sum=0; do { temp=(float)1/(2*n-1); if(n%2==1) sum+=temp; else sum-=temp; n++; }while(temp>=0.000001); printf(＂pi=%f\n＂,.
 
如何学好循环结构，我觉得循环结构的试题解决方法不容易想到。谢谢！
 
循环，每当你需要处理不止一条信息的时候，首先想到循环的方法。比如你要取出一个数组中的每一个元素，对其进行某些处理。(for循环)或者，你需要等待用户的某些操.

 

  
 
 
c语言 循环嵌套循环
 

  

   

    

     

      
Here you will learn about nested loops in C.
 
      
 在这里，您将了解C中的嵌套循环。 
 
      
Nesting is one of the most complex topics of C programming. Just like decision control instructions, a loop control instruction can also be nested easily. But sometimes understanding the execution of such programs could be a bit tricky. So it is important to make the basics clear.
 
      
 嵌套是C编程中最复杂的主题之一。 就像决策控制指令一样，循环控制指令也可以轻松嵌套。 但是有时了解此类程序的执行可能会有些棘手。 因此，弄清楚基础知识很重要。 
 
      
 C中的嵌套循环 (Nested loops in C)
 
      
As I said in my earlier tutorials, nesting means defining statement under the scope of another similar statement. In case of loops, when we nest two loops then it generally multiplies the execution frequency of loops.
 
      
 正如我在之前的教程中所说的，嵌套意味着在另一个类似语句的范围内定义语句。 在循环的情况下，当我们嵌套两个循环时，它通常会乘以循环的执行频率。 
 
      
We can nest for loop inside while loop and vice versa is also true. Generally programmer nest up to 3 loops. But there is no limit of nesting in C.
 
      
 我们可以在循环内嵌套for循环，反之亦然。 通常，程序员最多嵌套3个循环。 但是在C中嵌套没有限制。 
 
      
Now let’s try a small program with nested loops.
      
 现在让我们尝试一个带有嵌套循环的小程序。 
 
      
#include<stdio.h>
 
void main()
{
 int row,col;
 for(row=1;row<4;row++)
 {
  for(col=1;col<4;col++)
  {
   printf("%d\t%d\n",row,col);
  }
 }
}
 
      
Output
 
      
 输出量 
 
      

       
      
      
Explanation
 
      
 说明 
 
      
Every row executes a column at least 3 times. Therefore you are seeing all three values with every row.
 每行执行一列至少3次。 因此，您将在每一行看到所有三个值。 
Once the control reaches inside the inner loop, it came out only when the loop is fully executed.
 一旦控件到达内部循环内部，则仅在循环完全执行后才出现。 
We cannot alter the control once it reaches inside the inner loop.
 一旦控件进入内部循环，我们将无法对其进行更改。 
      
Note: I have deliberately shown a simple program to show nesting of loops. Execution of nested loops can’t be summarized in words. So it will be better if you try your hands on the nesting of loops to understand them better.
 
      
 注意：我故意显示了一个简单的程序来显示循环嵌套。 嵌套循环的执行不能用文字概括。 因此，如果您尝试循环嵌套以更好地理解它们，那就更好了。 
 
      
 奇数循环 (Odd Loop)
 
      
There are situations when we need to execute a set of instructions until the user deny it. So we need to check if the user wants to repeat the set of instructions or not.
 
      
 在某些情况下，我们需要执行一组指令，直到用户拒绝为止。 因此，我们需要检查用户是否要重复这组指令。 
 
      
In that case programmer has no idea about the executing time and frequency of the program. This is called odd loop in C programming. So basically we have to make a program which will ask to the user about the re-execution of program.
      
 在那种情况下，程序员不知道程序的执行时间和频率。 这在C编程中称为奇数循环。 因此，基本上我们必须制作一个程序，该程序将询问用户有关程序的重新执行。 
 
      
#include<stdio.h>
 
void main()
{
 char yes='Y';
 int x,y;
 
 while(yes=='Y')
 {
  printf("Enter two values to perform additionn");
  scanf("%d%d",&x,&y);
  printf("Sum is %d n",x+y);
  printf("Do you want to continue ? Press Y for Yes and N for Non");
  scanf("%c", &yes);
 }
}
 
     
    
   
  
  
Output
 
  
 输出量 
 
  

   
  
  
Explanation
 
  
 说明 
 
  
In the beginning I have character variable yes with character initial value ‘Y’. After that I have declared two more integer variables.
 一开始，我有字符变量yes，字符初始值为“ Y”。 之后，我又声明了两个整数变量。 
Now I have started while loop with condition yes==’Y’. It means the loop will be executed until it receives value ‘Y’.
 现在，我以条件yes =='Y'开始了while循环。 这意味着循环将一直执行，直到收到值“ Y”为止。 
After that I have displayed the message to enter two values. By using scanf() function I have stored data inside the variables.
 之后，我显示了输入两个值的消息。 通过使用scanf()函数，我将数据存储在变量中。 
Now instead of using a third variable to calculate sum. I have used a simple argument to calculate sum inside printf() function.
 现在，而不是使用第三个变量来计算总和。 我使用了一个简单的参数来计算printf()函数中的总和。 
In the end the program will display the message for user. If he wants to continue then he will press “Y”. Otherwise he will press “N” and the program will be terminated.
 最后，程序将为用户显示消息。 如果他想继续，那么他将按“ Y”。 否则，他将按“ N”，程序将终止。 
  
Comment below if you have doubts or found any information incorrect in above tutorial for nested loops in C.
 
  
 如果您有疑问或在上面的教程中对C中的嵌套循环有任何不正确的信息，请在下面评论。 
 
 
 

  
翻译自: https://www.thecrazyprogrammer.com/2015/01/nested-loops-in-c.html
 
 
c语言 循环嵌套循环

 
在C语言中采用3中语法来实现循环，它们分别是while、for、do while，本文将分别说明这三种循环的实现，并对它们的运行效率进行比较。
 
do while
 
首先来看do while的实现：下面是简单的代码：
 
int nCount = 0;
 
int nMax = 10;
 
do
 
{
 
nCount++;
 
} while (nCount < nMax);
 
return 0;
 
下面对应的是它的汇编代码：
 
9: int nCount = 0;
 
00401268 mov dword ptr [ebp-4],0
 
10: int nMax = 10;
 
0040126F mov dword ptr [ebp-8],0Ah
 
11: do
 
12: {
 
13: nCount++;
 
00401276 mov eax,dword ptr [ebp-4]
 
00401279 add eax,1
 
0040127C mov dword ptr [ebp-4],eax
 
14: } while (nCount < nMax);
 
0040127F mov ecx,dword ptr [ebp-4];exc = nCount
 
00401282 cmp ecx,dword ptr [ebp-8];比较nCount 和 nMax的值
 
00401285 jl main+26h (00401276);跳转到循环体中
 
15: return 0;
 
00401287 xor eax,eax
 
在汇编代码中首先执行了一次循环体中的操作，然后判断，当条件满足时会跳转回循环体，然后再次执行，当条件不满足时会接着执行后面的语句。
 
这个过程可以用goto来模拟：
 
int nCount = 0;
 
int nMax = 10;
 
__WHILE:
 
nCount++;
 
if(nCount < nMax)
 
goto __WHILE;
 
while循环
 
不同于do while的先执行再比较，while采取的是先比较再循环的方式，下面是一个while的例子：
 
int nCount = 0;
 
int nMax = 10;
 
while (nCount < nMax)
 
{
 
nCount++;
 
}
 
00401268 mov dword ptr [ebp-4],0
 
10: int nMax = 10;
 
0040126F mov dword ptr [ebp-8],0Ah
 
11: while (nCount < nMax)
 
00401276 mov eax,dword ptr [ebp-4]
 
00401279 cmp eax,dword ptr [ebp-8]
 
0040127C jge main+39h (00401289)
 
12: {
 
13: nCount++;
 
0040127E mov ecx,dword ptr [ebp-4]
 
00401281 add ecx,1
 
00401284 mov dword ptr [ebp-4],ecx
 
14: }
 
00401287 jmp main+26h (00401276)
 
15: return 0;
 
00401289 xor eax,eax
 
从汇编代码上可以看出，执行while循环时会有两次跳转，当条件不满足时会执行一次跳转，跳转到循环体外，而条件满足，执行完一次循环后，会再次跳转到循环体中，再次进行比较。相比于do while来说，while执行了两次跳转，效率相对较低。
 
for 循环
 
for循环是首先进行初始化操作然后进行比较，条件满足时执行循环，再将循环变量递增，最后再次比较，执行循环或者跳出。下面是for的简单例子：
 
int nMax = 10;
 
for (int i = 0; i < nMax; i++)
 
{
 
printf("%d\n", i);
 
}
 
下面是它对应的汇编代码：
 
9: int nMax = 10;
 
00401268 mov dword ptr [ebp-4],0Ah
 
10: for (int i = 0; i < nMax; i++)
 
0040126F mov dword ptr [ebp-8],0 ;初始化循环变量
 
00401276 jmp main+31h (00401281);跳转到比较操作处
 
00401278 mov eax,dword ptr [ebp-8]
 
0040127B add eax,1
 
0040127E mov dword ptr [ebp-8],eax;这三句话实现的是循环变量自增操作
 
00401281 mov ecx,dword ptr [ebp-8];ecx = i
 
00401284 cmp ecx,dword ptr [ebp-4];比较ecx与i
 
00401287 jge main+4Ch (0040129c);跳转到循环体外
 
11: {
 
12: printf("%d\n", i);
 
00401289 mov edx,dword ptr [ebp-8]
 
0040128C push edx
 
0040128D push offset string "%d\n" (0042e01c)
 
00401292 call printf (00401540)
 
00401297 add esp,8
 
13: }
 
0040129A jmp main+28h (00401278);跳转到i++位置
 
14: return 0;
 
0040129C xor eax,eax
 
从上面的汇编代码可以看出for循环的效率最低，它经过了3次跳转，生成对应的汇编代码上，初始化操作后面紧接着是循环变量自增操作，所以首先在完成初始化后会进行一次跳转，跳转到判断，然后根据判断条件再次跳转或者接着执行循环体，最后当循环完成后会再次跳转到循环变量自增的位置，同样采用goto语句来模拟这个操作：
 
int nMax = 10;
 
int i = 0;
 
goto __CMP;
 
__ADD:
 
i++;
 
__CMP:
 
if (i >= nMax)
 
{
 
goto __RETURN;
 
}
 
__LOOP:
 
printf("%d\n", i);
 
goto __ADD;
 
__RETURN:
 
return 0;
 
continue语句
 
continue用于结束这次循环进入下一次循环，下面采用最复杂的for循环来说明continue语句：
 
int nMax = 10;
 
int i = 0;
 
for(;i < nMax; i++)
 
{
 
if (i == 6)
 
{
 
continue;
 
}
 
}
 
下面是它对应的汇编代码：
 
00401268 mov dword ptr [ebp-4],0Ah
 
10: int i = 0;
 
0040126F mov dword ptr [ebp-8],0
 
11: for(;i < nMax; i++)
 
00401276 jmp main+31h (00401281)
 
00401278 mov eax,dword ptr [ebp-8]
 
0040127B add eax,1
 
0040127E mov dword ptr [ebp-8],eax
 
00401281 mov ecx,dword ptr [ebp-8]
 
00401284 cmp ecx,dword ptr [ebp-4]
 
00401287 jge main+43h (00401293)
 
12: { 13: if (i == 6) 00401289 cmp dword ptr [ebp-8],6;
 
0040128D jne main+41h (00401291);条件不满足组跳转到循环结束处
 
14: { 15: continue;
 
0040128F jmp main+28h (00401278)
 
16: } 17: } 00401291 jmp main+28h (00401278) 18: return 0;
 
00401293 xor eax,eax
 
从上面的汇编代码可以看到，continue语句也是一个跳转语句，它会直接跳转到循环体的开始位置。对于for来说相对特殊一些(我觉得循环变量自增并不属于循环体)，由于第一次进入循环时并没有执行循环变量自增，所以它会跳转到循环变量自增的位置，其他则直接到循环开始处。

判断一个数是否为素数
 
#include <stdio.h>
int main()
{
    int x;

    scanf("%d", &x);
    int i;
    int isprime = 1; //x是素数
    for ( i=2; i<x; i++) {
        if ( x % i == 0) {
            isprime = 0;
            break;
        }
    }
    if ( isprime==1) {
        printf("是素数\n");
    } else {
    printf("不是素数\n");
    }
    return 0;
}

 
嵌套循环
 
100以内的素数
 
#include <stdio.h>
int main()
{
    int x;
    
    for ( x=1; x<=100; x++) {
        int i;
        int isprime = 1;
        for ( i=2; i<x;i++) {
            if ( x % i ==0){
                isprime = 0;
                break;
            }
        }
        if ( isprime ==1) { 
            printf("%d ", x);
        }
    }
    return 0;
}

 
C语言经典例题 前50个素数
 
for循环
 
#include <stdio.h>
int main()
{
    int x;
    int cnt = 0;

    for ( x=2; cnt<50; x++) {
        int i;
        int isprime = 1;
        for ( i=2; i<x;i++) {
            if ( x % i ==0){
                isprime = 0;
                break;
            }
        }
        if ( isprime ==1) {
           cnt++;
           printf("%d\t", x);//制表对齐
           if ( cnt %5==0) {
            printf("\n");
           }
        }

    }
    return 0;
}

 
while循环
 
#include <stdio.h>
int main()
{
  int x;
  int cnt =0;
  x = 1;
  while ( cnt < 50) {
      int i;
      int isprime = 1;
      for ( i =2; i<x; i++) {
          if ( x % i == 0) {
              isprime = 0;
              break;
          }
      }
      if ( isprime == 1) {
          cnt ++;
          printf(" %d\t", x);
          if ( cnt %5 == 0) {
              printf("\n");
          }
      }
      x++;
  }
  return 0;
}

 
凑硬币
 
全部方案
 
#include <stdio.h>
int main()
{
    int x;//元
    int one, two, five;
    scanf("%d", &x);
    for ( one = 1; one < x*10; one++) {
        for ( two = 1; two < x*10/2 ;two++){
            for ( five =1; five < x*10/5 ;five++) {
                if ( one + two*2 + five*5 == x*10) {
                    printf(" 可以用%d个1角加%d个2角加%d个5角得到%d元\n", one,two, five,x);
                    
                }
            }
        }
    }

    return 0;
}

 
单个方案（接力break）
 
#include <stdio.h>
int main()
{
    int x;
    int one, two, five;
    int exit =0;
    scanf("%d", &x);
    for ( one = 1; one < x*10 ; one++) {
        for ( two =1; two < x*10/2 ; two++) {
            for ( five = 1; five < x*10/5; five++) {
                if ( one + two *2 + five*5==x*10) {
                    printf("可以用%d个一角加%d个2角加%d个五角得到%d元\n", one, two,five,x);
                    exit = 1;
                    break;
                }
            }
            if ( exit ) break;
        }
        if ( exit ) break;
    }
    return 0;
}
 
 
 
beerak与continue都是只能跳出当前循环
 
 
goto用法
 
#include <stdio.h>
int main()
{
    int x;
    int one, two, five;
    scanf("%d", &x);
    for ( one = 1; one < x*10; one++) {
        for ( two = 1; two < x*10/2; two++) {
            for ( five = 1; five < x*10/5; five++) {
                if ( one + two*2 + five*5 == x*10) {
                    printf("可以用%d个一角加%d个2角加%d个五角得到%d元\n", one, two, five, x);
                    goto out;
                }
            }
        }
    }
    out:
    return 0;
}

 
前n项和
 
题目：
 
#include <stdio.h>
int main()
{
    int n;
    int i;
    double sum = 0.0;

    scanf("%d", &n);
    for ( i = 1; i<=n; i++) {
        sum += 1.0/i;
    }
    printf("f(%d)= %f\n", n,sum);
    return 0;
}

 
 
#include <stdio.h>
int main()
{
    int n;
    int i;
    double sum = 0.0;
    int sign = 1;

    scanf("%d", &n);
    for ( i = 1; i<=n; i++) {
        sum += 1.0/i;
        sign = -sign;
    }
    printf("f(%d)= %f\n", n,sum);
    return 0;
}

 
#include <stdio.h>
int main()
{
    int n;
    int i;
    double sum = 0.0;
    //int sign = 1;
    double sign =1.0;
    scanf("%d", &n);
    for ( i = 1; i<=n; i++) {
        sum += sign/i;
        sign = -sign;
    }
    printf("f(%d)= %f\n", n,sum);
    return 0;
}

 
整数的正序分解
 
//无零整数
#include <stdio.h>
int main()
{
    int x;

    scanf("%d", &x);
    int t= 0;
    do {
        int d = x%10;
        t = t*10+d;
        x /=10;
    } while (x>0);
    printf(" x=%d, t=%d\n", x, t);
    x = t;
    do {
        int d= x % 10;
        printf("%d", d);
        if ( x>10) {
            printf(" ");
        }
        x /=10;
    } while ( x>0);
    printf("\n");
    return 0;

}

 
全部整数思维过程
 
 
 
x =13425
 
 
13425 / 10000 = 1
 
 
13425 % 10000 = 3425
 
 
10000 / 10 = 1000
 
 
3425 /1000 =3
 
 
3425 % 1000 = 425
 
 
1000 /10 = 100
 
 
425 /100 = 25
 
 
425 % 100 = 25
 
 
100 /10 = 10
 
 
25 / 10 = 5
 
 
25 % 10 = 5
 
 
10 /10 = 1
 
 
5 / 1 =1
 
 
5 % 1 = 5
 
 
1 / 10 = 0
 
 
70000/10000=7
 
 
70000%10000=0
 
 
#include <stdio.h>
int main()
{
  int x;

  scanf("%d", &x);
  int mask =1;
  int t = x;
  while ( t>9) {
      t /=10;
      mask *= 10;
  }
  //int mask = 10000;
  do {
      int d = x / mask;
      printf("%d", d);
      if ( mask>9 ) {
          printf(" ");
      }
      x %= mask; //x对mask取余
      mask /= 10;
      printf(" x=%d, mask=%d, d=%d\n", x, mask, d);
  } while ( mask > 0);

  printf("\n");
  return 0;

}

 
最大公约数
 
枚举法
 
# include <stdio.h>
int main()
{
    int a,b;
    int min;

    scanf("%d %d", &a,&b);
    if ( a>b) {
        min = a;
    } else {
        min = b;
    }
    int ret = 0;
    int i;
    for ( i=1; i<min;i++) {
        if ( a%i==0) {
            if ( b%i==0) {
                ret = i;
            }
        }
    }
    printf("%d和%d的最大公约数是%d.\n", a,b,ret);
    return 0;
}

 
辗转相除法
 
 
#include <stdio.h>
int main()
{
    int a,b,t;
    scanf("%d %d", &a,&b);
    while ( b != 0) {
        t = a%b;
        a=b;
        b=t;
        printf("a=%d,b=%d,t=%d\n", a, b, t);
    }
    printf("gcd=%d\n", a);
    return 0;
}