例题1：给定两个字符串char s[200],和char t[200],将t中的内容连接到s的尾部形成新串
例题2：给定一个字符串char s[200],由字母字符组成,将大写字符改成小写，小写改成大写。
例题3：给定一个字符串char s[200],将其中字母字符改成下一个字符a->b,b->c...z->a大写仍大写，小写仍小写，其他字符不变
例题4：给定一个字符串char s[200],将其逆置后输出
例题5：给定一个字符串char s[200],char t[200],将s中ASCII值为偶且下标为偶的字符存入t中形成新串并输出
例题6：给定一个字符串char s[200],由字母和星号组成
         6.1删除前导星号
         6.2删除后导星号
         6.3删除中间星号
         6.4使前导星号个数不多于n个
         6.5使后导星号个数不多于n个

例题1：给定两个字符串char s[200],和char t[200],将t中的内容连接到s的尾部形成新串
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="chinese";
      char t[200]="kongfu";
      int i,c;
     

      c=strlen(s);
      for(i=0;i<=strlen(t);i++)
      {
            s[c++]=t[i];
      }

      puts(s);
}

例题2：给定一个字符串char s[200],由字母字符组成,将大写字符改成小写，小写改成大写。
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="aBCdefGhiJ";
      int i;
     

      for(i=0;s[i]!='\0';i++)
      {
            if(s[i]>='a'&&s[i]<='z')
                  s[i]-=32;
            else
                  s[i]+=32;
      }

      puts(s);
}

例题3：给定一个字符串char s[200],将其中字母字符改成下一个字符a->b,b->c...z->a大写仍大写，小写仍小写，其他字符不变
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="Mn.123xyz";
      int i;
     

      for(i=0;s[i];i++)
      {
            if(s[i]>='a'&&s[i]<='y'||s[i]>='A'&&s[i]<='Y')
                  s[i]+=1;
            else
                  if(s[i]=='z'||s[i]=='Z')
                        s[i]-=25;
      }

      puts(s);
}
例题4：给定一个字符串char s[200],将其逆置后输出
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="Mn.123xyz";
      int i,j;
      char t;
     

      i=0;
      j=strlen(s)-1;
      while(i<j)
      {
            t=s[i];
            s[i]=s[j];
            s[j]=t;
            i++;
            j--;
      }

      puts(s);
}
例题5：给定一个字符串char s[200],char t[200],将s中ASCII值为偶且下标为偶的字符存入t中形成新串并输出
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="Mn.123xyz";
      int i,c;

      c=0;
      for(i=0;s[i];i++)
      {
            if(s[i]%2==0&&i%2==0)
                  t[c++]=s[i];
      }
      t[c]='\0';

      puts(s);
}

例题6：给定一个字符串char s[200],由字母和星号组成
删除后导星号
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="******ab**c**d***e**fg*********";
      int j;

      j=strlen(s)-1;
      while(s[j]=='*')
      {
            j--;
      }
      s[j+1]=0;

      puts(s);     
}

例题6：给定一个字符串char s[200],由字母和星号组成
删除中间星号
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="******ab**c**d***e**fg*********";
      int i,j,k,c;

      i=0;
      while(s[i]=='*')
      {
            i++;
      }
      j=strlen(s)-1;
      while(s[j]=='*')
      {
            j--;
      }
      c=0;
      for(k=0;s[k];k++)
      {
            if( !(k>=i&&kk<=j&&s[k]=='*') )
                  s[c++]=s[k];
      }
      s[c]=0;

      puts(s);     
}

例题6：给定一个字符串char s[200],由字母和星号组成
使后导星号不多余n个
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="******ab**c**d***e**fg*********";
      int j,c,n;
      scanf("%d",&n)

      c=0;
      j=strlen(s)-1;
      while(s[j]=='*')
      {
            j--;
            c++;
      }
      if(c>n)
      {
            s[j+n+1]=0;
      }

      puts(s);     
}

例题6：给定一个字符串char s[200],由字母和星号组成
使前导星号不多余n个
#include <stdio.h>
#include <string.h>
void main()
{
      char s[200]="******ab**c**d***e**fg*********";
      int i,k,c,n;
      scanf("%d",&n)

      i=0;
      while(s[i]=='*')
      {
            i++;
      }
      if(i>n)
      {
            c=0;
            for(k=i-n;k<=strlen(s);k++)
                  s[c++]=s[i];
      }

      puts(s);     
}
 

例题1：给定一个二维数组int a[5][6];求二维数组的累加和
例题2：给定一个二维数组int a[5][6];求其最大值
例题3：给定一个二维数组int a[5][5];将其下三角元素清成0
例题4：给定一个二维数组int a[5][5];将其上三角元素乘以2
例题5：给定一个二维数组int a[5][5];输出其对角线上元素的值
例题6：给定一个二维数组int a[5][5];输出其副对角线上元素的值
例题7：给定一个二维数组int a[5][6];和int b[5];分别求出a中各行的累加和并存入b中
例题8：给定一个二维数组int a[5][6];和int c[6];分别求出a中各列的最大值并存入c中
例题9：给定一个二维数组int a[5][6];以行为单位进行逆置并输出
例题10：给定一个二维数组int a[5][6];以列为单位进行逆置并输出
例题11：给定一个二维数组int a[5][5];将其转置后输出
例题12：给定一个二维数组int a[5][5];和int b[5][5];将A+A'->B

例题1：给定一个二维数组int a[5][6];求二维数组的累加和
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,1,3},
            {6,14,3,5,6,3},
            {9,55,6,21,2,8},
            {12,3,21,41,1,12},
            {14,2,3,4,6,34}
      };
      int i,j,s;

      s=0;
      for(i=0;i<5;i++)
      {
            for(j=0;j<6;j++)
            {
                  s+=a[i][j];
            }
      }

      printf("SUM=%d",s);
}

例题2：给定一个二维数组int a[5][6];求其最大值
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,1,3},
            {6,14,3,5,6,3},
            {9,55,6,21,2,8},
            {12,3,21,41,1,12},
            {14,2,3,4,6,34}
      };
      int i,j,max;

      max=a[0][0];
      for(i=0;i<5;i++)
      {
            for(j=0;j<6;j++)
            {
                  if(a[i][j]>max)
                        max=a[i][j];
            }
      }

      printf("MAX=%d",max);
}

例题3：给定一个二维数组int a[5][5];将其下三角元素清成0
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int i,j;

      for(i=0;i<5;i++)
      {
            for(j=0;j<=i;j++)
            {
                  a[i][j]=0;
            }
      }

      for(i=0;i<5;j++)
      {
            for(j=0;j<5;j++)
            {
                  printf("%3d",a[i][j]);
            }
            printf("\n");
      }
}

例题4：给定一个二维数组int a[5][5];将其上三角元素乘以2
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int i,j;

      for(i=0;i<5;i++)
      {
            for(j=i;j<5;j++)
            {
                  a[i][j]*=2;
            }
      }

      for(i=0;i<5;i++)
      {
            for(j=0;j<5;j++)
            {
                  printf("%3d",a[i][j]);
            }
            printf("\n");
      }
}

例题5：给定一个二维数组int a[5][5];输出其对角线上元素的值
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int i;

      for(i=0;i<5;i++)
      {
            printf("%3d",a[i][i]);
      }
}

例题6：给定一个二维数组int a[5][5];输出其对副角线上元素的值
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int i;

      for(i=0;i<5;i++)
      {
            printf("%3d",a[i][5-i-1]);
      }
}

例题7：给定一个二维数组int a[5][6];和一维数组int b[5];分别求出二维数组每行的累加和并存入数组int b[5]中
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,4,8},
            {6,14,3,5,6,9},
            {9,55,6,21,2,23},
            {12,3,21,41,1,67},
            {14,2,3,4,6,56}
      };
      int b[5];
      int i,j,s;

      for(i=0;i<5;i++)
      {
            s=0;
            for(j=0;j<6;j++)
            {
                  s+=a[i][j];
            }
            b[i]=s;
      }

      for(i=0;i<5;j++)
      {
            printf("%3d",b[i]);
      }
}

例题8：给定一个二维数组int a[5][6];和一维数组int c[6];分别求出各列最大值并存入数组int c[6]中
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,4,8},
            {6,14,3,5,6,9},
            {9,55,6,21,2,23},
            {12,3,21,41,1,67},
            {14,2,3,4,6,56}
      };
      int c[6];
      int i,j,max;

      for(j=0;j<6;j++)
      {
            max=a[0][j];
            for(i=0;i<5;i++)
            {
                  if(a[i][j]>max)
                        max=a[i][j];
            }
            c[j]=max;
      }

      for(i=0;i<6;j++)
      {
            printf("%3d",c[i]);
      }
}

例题9：给定一个二维数组int a[5][6];以行为单位进行逆置并输出
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,4,8},
            {6,14,3,5,6,9},
            {9,55,6,21,2,23},
            {12,3,21,41,1,67},
            {14,2,3,4,6,56}
      };
      int p,q,j,t;

      p=0;
      q=4;
      while(p<q)
      {
            for(j=0;j<6;j++)
            {
                  t=a[p][j];
                  a[p][j]=a[q][j];
                  a[q][j]=t;
            }
            p++;
            q--;
      }

      for(i=0;i<5;i++)
      {
            for(j=0;j<6;j++)
            {
                  printf("%3d",a[i][j]);
            }
            printf("\n");
      }
}

例题10：给定一个二维数组int a[5][5];以列为单位进行逆置并输出
#include <stdio.h>
void main()
{
      int a[5][6]={
            {3,12,6,7,4,8},
            {6,14,3,5,6,9},
            {9,55,6,21,2,23},
            {12,3,21,41,1,67},
            {14,2,3,4,6,56}
      };
      int x,y,i,t;

      x=0;
      y=5;
      while(x<y)
      {
            for(i=0;i<5;i++)
            {
                  t=a[i][x];
                  a[i][x]=a[i][y];
                  a[i][y]=t;
            }
            x++;
            y--;
      }

      for(i=0;i<5;i++)
      {
            for(j=0;j<6;j++)
            {
                  printf("%3d",a[i][j]);
            }
            printf("\n");
      }
}

例题11：给定一个二维数组int a[5][5];将其转置后输出
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int i,j,t;

      for(i=0;i<5;i++)
      {
            for(j=0;j<i;j++)
            {
                  t=a[i][j];
                  a[i][j]=a[j][i];
                  a[j][i]=t;
            }
      }

      for(i=0;i<5;i++)
      {
            for(j=0;j<5;j++)
            {
                  printf("%3d",a[i][j]);
            }
            printf("\n");
      }
}

例题12：给定一个二维数组int a[5][5];和int b[5][5];将A+A'->B
#include <stdio.h>
void main()
{
      int a[5][5]={
            {3,12,6,7,4},
            {6,14,3,5,6},
            {9,55,6,21,2},
            {12,3,21,41,1},
            {14,2,3,4,6}
      };
      int b[5][5];
      int i,j;

      for(i=0;i<5;i++)
      {
            for(j=0;j<5;j++)
            {
                  b[i][j]=a[i][j]+a[j][i];
            }
      }

      for(i=0;i<5;i++)
      {
            for(j=0;j<5;j++)
            {
                  printf("%3d",b[i][j]);
            }
            printf("\n");
      }
}

      s=0;
      for(i=0;i<10;i++)
      {
            s+=a[i];
      }
 

      printf("SUM=%d\n",s);
      printf("AVER=%f",s/10.0);
}

例题2：给定一位数组int a[10]，求其最大值并输出
#include <stdio.h>
void main()
{
      int a[10]={3,15,2,19,64,52,73,94,11,6};
      int i,max;
     

      max=a[0];
      for(i=1;i<10;i++)
      {
            if(a[i]>max)
                  max=a[i];
      }
 

      printf("MAX=%d",max);
}

例题3：给定一位数组int a[10]，求其最大值和最大值所在的下标并输出
#include <stdio.h>
void main()
{
      int a[10]={3,15,2,19,64,52,73,94,11,6};
      int i,max,k;
 

      max=a[0];
      k=0;
      for(i=1;i<10;i++)
      {
            if(a[i]>max)
            {
                  max=a[i];
                  k=i;
            }
      }
 

      printf("MAX=%d\n",max);
      printf("MAXPOS=%d",k);
}

例题4：给定一位数组int a[10]，求其最大值和最大值所在的下标并输出
#include <stdio.h>
void main()
{
      int a[10]={3,15,2,19,64,52,73,94,11,6};
      int i,k;
 

      k=0;
      for(i=1;i<10;i++)
      {
            if(a[i]>a[k])
                  k=i;
      }
 

      printf("MAX=%d\n",a[k]);
      printf("MAXPOS=%d",k);
}

例题5：给定一位数组int a[10]，将其逆置后输出
#include <stdio.h>
void main()
{
      int a[10]={3,15,2,19,64,52,73,94,11,6};
      int i,j,t;
 

      i=0;
      j=9;
      while(i<j)
      {
            t=a[i];
            a[i]=a[j];
            a[j]=t;
            i++;
            j--;
      }
 

      for(i=0;i<10;i++)
            printf("%d ",a[i]);
}

例题6：寻找200到400之间能被7或11整除的数存入数组int a[200]中并输出
#include <stdio.h>
void main()
{
      int a[200];
      int i,c;
 

      c=0;
      for(i=200;i<=400;i++)
      {
            if(i%7==0||i%11==0)
                  a[c++]=i;
      }
 

      for(i=0;i<c;i++)
            printf("%d ",a[i]);
}

再来看while循环
初始;
while(条件)
{
     循环体;
     控制;
}
他的执行过程如下图所示：

还是刚才for循环语句的三个因素用到while循环语句中
i=1;
while(i<=10)
{
     printf("%4d",i);
     i++;
}
和刚才情况一样，我们继续考虑循环体被执行的次数和循环结束后变量i的值，我们可以看到效果是完全一样的。

再看do-while循环

初始;
do
{
     循环体;
     控制;
}while(条件);
他的执行过程如下图所示：

还是刚才for循环语句的三个因素用到do-while循环语句中
i=1;
do
{
     printf("%4d",i);
     i++;
}while(i<=10);
和刚才情况一样，我们继续考虑循环体被执行的次数和循环结束后变量i的值，我们可以看到效果是完全一样的。循环体依然是在变量i从1到10执行到10次，循环结束后变量i的值是11。
我们可以看到这三个循环语句都是“条件成立时进行循环，条件不成立时退出循环”，都是“当型循环”，“直到型循环”的执行过程是“条件不成立时进行循环，直到条成立时退出循环”，我们在这里不研究“直到型循环”。

do-while和while的区别之处是：当初始条件不成立时，do-while结构比while多执行一次。也就是说do-while循环结构无论如何都会让循环体部分至少执行1次，而初始条件不成立while结构不执行循环体。
例如
i=100;
do
{
     printf("%4d",i);
     i++;
}while(i<=10);
循环体被执行1次，输出结果是100，循环结束后变量i的值是101

i=100;
while(i<10)
{
     printf("%4d",i);
     i++;
}
循环体被执行0次，没有输出，循环结束后变量i的值是100

经过比较我们发现无论用什么语句来实现，最终都是为了控制一个次数，而次数控制主要是通过初始，条件，控制三个因素来完成，应什么语句实现并不是很重要，所以我们推荐大家使用for语句进行循环的控制。因为他把进行循环次数控制的各个部分写在一起，这样的话不容易“丢项”。

用for语句进行次数控制的时候有两个很容易出错的地方，一个是初始值从0开始和从1开始，另一个是条件中<和<=。常见的进行10次控制的语句如下两种形式
for(i=1;i<=10;i++)
{
     循环体;
}

变量i的值分别是1到10时执行循环体。
for(i=0;i<10;i++)
{
     循环体;
}
变量i的值分别是0到9时执行循环体。

2.循环的应用
循环结构是结构化程序设计中最重要的流程控制方式，很多问题的处理过程中都需要使用循环结构来实现，我们这里举三个循环结构能解决的常见问题：累加和，穷举搜索，素数判断来学习循环结构。我们学习这三种问题的时候都是要先给出解决这类问题的基本框架，然后举例说明，接下来再通过独立去做类似的练习题的方式来学习，也就是三个关键词：框架->例题->习题

累加和
我们先从求1+2+3+4+……100这个累加和求解的流程图来分析求解累加和的基本框架

我们可以看的出来，变量i起到了控制次数的作用，而次数控制对于进行累加和求解的问题而言比较简单，那就是根据累加和需要累加数据的个数来确定。而变量s的作用是求累加和，因此这个流程中剩下的比较难的地方就是要看每次s要累加上的表达式该怎样写才能正确的表示各个项。
这就要去寻找累加和各项之间的一种规律，并将这种规律以表达式的方式写在s=s+表达式;语句中，
这种规律有两种寻找的途径，一是看看各个需要累加的项的值是否和循环控制变量i有关，如果是这样的话则可以将表达式写成i的表达式来表示需要累加的各项的值，例如：1+2+3+4+……+100这个题目中，每次需要累加的值就可以用i来表示。

switch-case语句


第一种形式是通过判断条件是否成立，选择执行两方中的某一方。第二种形式是判断测试表达式的值和那个值匹配，执行相应的支上的语句。
1.基本结构
  A;
  if(条件)
  {
          支语句1;
  }
  else
  {
          支语句2;
  }
  B;
  在基本结构种我们特别强调两个方面
  a)承前启后的语句A和语句B，这两个语句并不是选择语句，而是选择语句之前后之后的两个语句，无论条件是否成立，这两条语句都会被执行到，这一点从流程控制图上能清楚的看到，我们在设计的时候一定要考虑一下那条语句执行后开始进行选择语句和选择执行某个分支语句之后用接着从那条语句开始执行。
  b)注意组合语句的使用，如果支语句中是多条语句，那么一定要用组合语句符{}把他们括起来才行，否则计算机只将其中第一条作为支上的部分，后面的会认为是主干上的部分，当然如果只是一条语句的话，用{}括起来可以，不用也可以。因此我建议大家无论支语句是一条还是多条，都先用一对大括号括起来，保证不会出错，而后发现只是将一条括起来的话，也可以去掉。这样就不容易出错了。
例题：输入两个数字，找出较大的数字并输出
#include <stdio.h>
void main()
{
     int a,b,max;
     scanf("%d%d",&a,&b);
    
     if(a>b)
          max=a;
     else
          max=b;
  
     printf("MAX=%d",max);
}
测试：
输入12 67
结果输出67

输入98 53
结果输出98
2.选择嵌套
选择结构的基本语句，经过条件判断，只能是成立或不成立，选择执行其中一方，这样的结构似乎只是将流程分成了“两路”，而我们在设计的时候肯定会遇到根据当时的状况需要将流程分成“多路”的需要，那么利用if-else结构怎样才能实现呢？那么这就需要我们在选择语句的支语句中采用选择语句，也就是说在支上再分支，也可以说成是：分支语句的支语句1或支语句2本身又是一个选择结构语句。这样以来就能实现根据情况选择“多路”中的某一路来执行了。那么这个时候我们就要考虑这样的程序我们应该怎样进行设计呢。我们的办法是借助N-S流程图帮我们进行这种比较复杂的选择结构的设计。
题意 N-S流程图 程序
例题：输入三个数，找出最大的数字并输出
找到三个数字中的最大值的N-S图如下：

根据N-S图写出的程序如下
#include <stdio.h>
void main()
{
     int a,b,c,max;
     scanf("%d%d%d",&a,&b,&c);
   
     if(a>b)
     {
          if(a>c)
               max=a;
          else
               max=c;
     }
     else
     {
          if(b>c)
               max=b;
          else
               max=c;
     }

     printf("MAX=%d",max);
}
测试：
输入3 4 5
结果输出5
输入50 40 30
结果输出50
输入400 500 300
结果输出500

我们得到这样一个结论：从题意得到N-S图，主要是要特别注意分析，而从N-S图写出程序的过程则必须要按照从内向外的顺序一层一层写。

例题：输入一个百分制的成绩，判断这个成绩的等级成绩并输出。
根据N-S图写出的程序如下


根据N-S图写出的程序如下
#include <stdio.h>
void main()
{
     int x;
     printf("Please Input a number:\n");
     scanf("%d",&x);

     if(x>=90)
          printf("A");
     else
     {
          if(x>=80)
               printf("B");
          else
           {
               if(x>=60)
                    printf("C");
               else
                    printf("D");
          }    
     }
}
测试：
分别输入95，82，77，31等数据进行测试，观察是否输出相应的结果

可以改变成
#include <stdio.h>
void main()
{
     int x;
     printf("Please Input a number:\n");
     scanf("%d",&x);

     if(x>=90)
          printf("A");
     else if(x>=80)
          printf("B");
     else if(x>=60)
          printf("C");
     else
          printf("D");
}

测试：
分别输入95，82，77，31等数据进行测试，观察是否输出相应的结果

另一种N-S图如下：

根据N-S图写出的程序如下：
#include <stdio.h>
void main()
{
     int x;
     printf("Please Input a number:\n");
     scanf("%d",&x);
 
     if(x>=60)
     {
          if(x>=80)
          {
               if(x>=90)
                    printf("A");
               else
                    printf("B");
          }
          else
               printf("C");
     }
     else
          printf("D");  
}
测试：
分别输入95，82，77，31等数据进行测试，观察是否输出相应的结果

可改变成
#include <stdio.h>
void main()
{
     int x;
     printf("Please Input a number:\n");
     scanf("%d",&x);
 
     if(x>=60)
          if(x>=80)
               if(x>=90)
                    printf("A");
               else
                    printf("B");
          else
               printf("C");
     else
          printf("D");  
}

测试：
分别输入95，82，77，31等数据进行测试，观察是否输出相应的结果

例题：输入一个年份，判断给定的年份是否是闰年。闰年的判断条件是能被4整除同时不能被100整除是闰年，能被400整除是闰年。
判断一个年份是否是闰年的N-S流程图如下

程序如下
#include <stdio.h>
void main()
{
     int year;
     printf("Enter a num");
     scanf("%d",&year);
  
     if(year%400==0)
          printf("Yes");
     else
     {
          if(year%4==0)
          {
               if(year%100==0)
                    printf("No");
               else
                    printf("Yes");
          }
          printf("No");
     }
}

程序中最主要的主题部分也可以用逻辑运算表示
#include <stdio.h>
void main()
{
     int year;
     printf("Enter a num");
     scanf("%d",&year);
  
     if((year%400==0)||(year%4==0&&year%100!=0))
          printf("Yes");
     else
          printf("No");
}

测试：
输入2003 输出No
输入2004 输出Yes
输入2000 输出Yes
输入1900 输出No

3.当else部分是空语句的时候
  当else部分是空语句的时候else和空语句可以省略不写
  A;
  if(条件)
     支语句1;
  else
     ;
  B;

  可以写成
  A;
  if(条件)
     支语句1;
  B;
  他们的执行过程可以用下面的流程图来表示

  这个知识点经常是在我们阅读程序的时候出现，也就是如果给定了一个选择结构程序让我们阅读程序写结果，那我们发现else部分如果没有的话，必须意识到这表示else部分是空语句，而后面的语句是主干上的部分。
例题：编写程序输入两个数字，将他们从小到大进行输出。
分析主题部分的算法：如下图所示

因此程序如下
#include <stdio.h>
void main()
{
     int a,b,c,t;
     scanf("%d%d%d",&a,&b,&c);

     if(a>b)
      {
          t=a;   a=b;   b=t;
     }
     if(a>c)
     {
          t=a;   a=c;   c=t;
     }
     if(b>c)
     {
          t=b;   b=c;   c=t;
     }

     printf("%d   %d   %d",a,b,c);
}

4.考点总结
编写选择嵌套程序，上机考试，办法是：题意  N-S流程图  程序
阅读选择嵌套程序写结果，笔试考试，办法是：一要搞清楚else和if的配套关系，二是要注意当else是空语句的这种现象
因为编写选择嵌套结构程序的例子我们在前面已经写了很多了，这里不再举例了，这里就说说阅读选择嵌套程序的事情。
首先要搞清楚else和if的配套关系：C规定，从内层开始，else总是和其向上最近的if配套，形成一条选择语句。
那么如何根据这个配套原则来阅读程序呢？看下面两个例子
例题
#include <stdio.h>
void main()
{
     int a=2,b=3,c=4,d=5;
     if(d<b)
          printf("%d",d+1);
     else if(a<c) printf("%d",d+2);
        else printf("%d",d+3);
}

输出7
#include <stdio.h>
void main()
{
   int a=2,b=3,c=4,d=5;
   if(b>a)
      if(c>d)
         printf("%d",d+10);
    else
       printf("%d",d+20);
}
输出25

顺序结构是程序中最大量存在而又最简单的一种，我们需要从一下三个方面来掌握
1.完成程序的框架
2.上机调试程序的过程
3.基本输入输出语句

1.完成程序框架
#include <stdio.h>
void main()
{
      读入数据
      程序主体（处理数据）
      输出结果
}
这里有两层含义要传达给大家：首先是如果初学者在写程序的时候实在是不知道该写点什么东西了，那你可以按照这个框架的结构来写，比如开始的时候可以考虑将程序中需要进行处理的数据通过定义变量并赋值的方式存到内存里，而后考虑数据处理的算法问题，最后将结果进行输出，这个思路对于编写结构化程序来说非常重要。其次是说读入数据和输出结果这两个部分的学习很简单主要是将进行输入和输出的语法记住就可以了，没有太多的需要理解和灵活的地方，而数据处理中不光是要学会语法，更重要的是要学习和掌握各种数据处理的算法，而算法是一个灵活的问题，因此学习起来首先是要理解（主要在课堂上在老师的帮助下完成），然后是要在上机实践中通过反复练习记住他（主要在课后独立练习）。

2.上机调试程序的过程
这里我们给出调试的理论知识，更详细的过程请参考动画演示


保存后会生成一个扩展名是.C的文件，我们称之为源程序文件
编译后会生成一个扩展名是.OBJ的文件，我们称之为目标文件，这个文件并不能被执行
连接后会生成一个扩展名是.EXE的文件，我们称之为是可执行程序

3.基本的输入输出语句
C语言中的输入和输出主要是靠scanf函数和printf函数来完成，输入主要是在程序刚开始的时候来完成灵活的数据读入，而输出语句主要是用在程序的结束的部分用于结果的输出。这里的大部分知识大家可以通过看书来自学，我们在这里只是给出一些重点部分和容易出错部分的总结
输出
printf("输出格式",变量名列表);
不带变量的输出
printf("Hello World");
带变量的输出
int a=10,b=76;
printf("%d   %d",a,b);               输出到屏幕上的结果是
10   76

printf("a=%d\nb=%d",a,b);     输出到屏幕上的结果是
a=10
b=76

printf("%d+%d=%d",a,b,a+b); 输出到屏幕上的结果是
10+76=86

输出格式中的格式控制符解释如下
整型表达式：
    %d        十进制整型
    %o        八进制整型
    %x        十六进制整型
    %ld       长整型
    %6d      不够6位用空格补齐6位，超过六位则原样输出
因为一个整数在程序中允许以不同的进制进行输出，所以这里我们就需要学会简单的进制转化
十进制→其他进制
其他进制→十进制

实型表达式:
    %f         单精度实型数据
    %lf        双精度实型数据
    %5.2f    输出总宽度占5位，小数点后输出2位

1.关于字符型数据参与算术运算
由于字符数据存放到计算机内存里时，实际存放的是该字符的ASCII值，也就是一个整数。因此字符是可以参与算术运算的，运算规则是用字符的ASCII值进行运算
需要记住的一些字符的ASCII值
    '0'     48
    '1'     49
    '2'     50
    '3'     51
    '4'     52
    '5'     53
    '6'     54
    '7'     55
    '8'     56
    '9'     57

    'A'     65
    'B'     66
    ......
    'Z'     90

    'a'     97
    'b'     98
    ......
    'z'     112
字符型数据常见的算术运算有
+1   -1 可以得到该字符的下一个字符或是上一个字符。'a'+1的结果是'b','f'-1的结果是'e'
+32  -32 作用给字母字符，可以得到切换大小写字母。  'G'+32的结果是'g','m'-32的结果是'M'
-48  作用给数字字符，可以得到数字字符相应的数值。'3'-48的结果是3，'8'-48的结果是8

2.关于算数值与逻辑值的关系
可以先想想下列表达式的结果
    int a=3,b=-7;
    a&&b
    a||b
    !a
    a+b
    可能有人会解释说上面的表达式会有语法错误，理由是逻辑运算的双方必须是逻辑值参与，而a和b中的值并非是逻辑值（1或0）
    其实在C语言中，上面的这些表达式是可以执行的
    C语言规定，当算数值非0（不是0）时其逻辑值就是成立1，当算数值是0的时候，逻辑值就是不成立0。因此
    a&&b 1&&1 结果是1
    a||b 1||1 结果是1
    !a  !1 结果是0 不能解释成a是3，!a的结果是-3,原因是！是逻辑运算，必须是用逻辑值进行参与
    a+b  3+(-7) 结果是-4 不能解释成1+1结果得2，原因是+是算术运算，则是用算数值参与
    这里可能有点晕，a和b有时候要当成3与-7进行运算，而有时候要当成1进行运算，这到底怎么确定呢？那当然是要看这个变量到底是参与逻辑运算还是算术运算来确定了。
    这种规则可能的应用场合有两个：一个是我们上面看到的逻辑运算中，另一个是在条件中
    int a=3,b=-7; 
    if(a>b)
       printf("%d",a);
    else
       printf("%d",b);

    if(a+b)
       printf("%d",a+b);
    else
       printf("%d",a-b);
   
    if(a==b)
       printf("yes");
    else
       printf("no");
     
    if(a=b)
       printf("YES");
    else
       printf("NO");
    四个程序片段中的条件部分都从语法角度来说都是正确的。
    红色的条件是一个关系运算，这个结果当然很明显3>-7是成立的，所以打印输出a的值3
    蓝色的条件是一个算术表达式，计算结果得到-4，-4作为条件也是可以的，这个时候就要用到我们说的算数值与逻辑值之间的关系了，所以-4作为条件成立，输出-4
    粉色的条件是一个关系表达式，由于3等于-7不成立，因此输出no
    黑色的条件是一个赋值表达式，首先将b的值赋给a，（并不是判断a与b是否相等），然后赋值表达式的值-7作为条件判断是成立，输出YES
这个例子告诉我们，写条件的时候=和==在C语言中是两个不同的运算符，一个是作赋值运算，而另一个是判断两方是否相等，相等得到1，不相等得到0，所以我们在使用的时候要非常小心，不要搞混了。

3.变量的命名规则
   变量标示符（也就是变量的名字）的规则有三条
   只能用字母或下划线开头（不能用数字开头）
   只能用字母、下划线、数字组成（不能用除此之外的任何其他字符例如：.  ?  >  -  $ 等）
   不能使用关键字（C语言严格区分大小写，所有关键字是小写字母；函数名不是关键字）
   3Com 不合法，数字开头
   line-4 不合法，使用了中划线，也就是减号
   A.c  不合法，使用了.
   main 合法，函数名main并不是关键字
   For  合法，用于循环控制的语句是for
   long 不合法，关键字
   _12  合法

4.常量的表示方法
各种不同类型的常量在表示的时候有多种形式
整型常量
可以加前缀用来标示不同进制的整数。加前缀523,0523,0X5A分别表示十进制、八进制和十六进制整数但需要注意的是：组成各种进制数的数字范围是什么：十进制是0到9这是个数字组成，八进制则是由0到7这八个数字组成，十六进制数则由0到9以及A到F这十六个符号组成，也就是说八进制数中只能出现0到7而不能有8，9出现，而十六进制数中不但可以有0到9，还可以出现A到F。而这一点经常在考试中出现，让考生判断整型常量的正确与否，我们刚刚提到的范围和前缀符就成了考点
    例如：
    判断下列整型常量中哪些正确，哪些错误
    0386 错误，0开头表示是八进制数字，而八进制中不能有8
    0xABF 合法的十六进制数
    0Xabd 合法的十六进制数
    xABF 不合法，整型常量中的十六进制必须以0X作前缀，不能用X作前缀
    -321 合法
    +325     合法，由于默认是正数，所以表示正数的时候可以省略+号
可以加后缀表示不同类型的整数。加后缀12,12L
    不加L表示是一个短整型整数，而加了L后缀则表示一个长整型数据。
    在个别一些情况下会有一些小小的差异
    比如：
    long x;
    x=5000*5000;
在这个语句中能不能把25000000这个结果存入x中能，可能我们会因为考虑到x是长整型类型的变量可以足以存放这个结果，所以认定会正确执行，但是情况并不是我们想想的那样。原因是什么呢：是因为5000这个没有L后缀的整数计算机视作是短整型数据，而两个短整型数据运算的结果也必须是短整型，而这个结果已经超过了短整型可以表示的结果，因此会出问题。这里可能有同学搞不清楚为什么x是长整型而却没有得到25000000呢，那你可以想想这个问题double x;  x=1/2;首先定义实型变量x，当然是一个可以存放实数的变量，第二步将1/2的结果存入x中，1和2都是整型类型数据，所以一定是先要得到整型类型的结果，然后给x赋值，不能应为是用实型变量来存储就要得到实型结果，运算的结果是什么类型只能参与运算双方的类型有关系。正确的将250000000存入x的语句应该是x=5000L*5000L;
实型常量
普通表示法和科学计数法，普通表示法主要是通过小数点表示一个实数，例如：3.14，3.0，.5，5.这些都是合法的实数，但是在表示非常大或是非常小的实数的时候不是很方便，这时候需要使用科学计数法进行表示，科学计数法的格式是nEm的形式，表示n乘10的m次方这个数，有一个要求就是：E前必须有数字，E后必须是整数
    2.9E3 正确
    2.5E+5 正确
    E2  不正确，E前没有数字，1E2是正确的表示
    2.5E3.1 不正确，E后不是整数
    2.5E3%25 不正确，实数不能参与%运算
字符常量
字符常量有两种表示方法，普通表示法和转义字符表示法。绝大多数字符都可以用普通表示法进行表示，例如：'A','?','5'等等，用一对单引号包括起来，一对单引号里只能包括一个字符，不能出现多个字符，否则就成了语法错误。但是一些特殊的字符就不能用普通方法表示，首先就是单引号字符本身，这样以来就只能借助转义字符的形式来表示，转义字符的基本格式是'\转义内容'，所以单引号字符表示成'\'',而这样以来，反斜线字符也不能通过普通方法表示了,'\'这样的写法是语法错误，不表示任何字符常量，反斜线字符应该表示成'\\',双引号表示成'\"',转义还可以通过字符的ASCII值表示一个字符常量，'\ddd','\Xhh',其中ddd表示一个八进制数字，hh表示一个十六进制数字，这里默认是八进制数字，因此八进制可以不同0开头，例如'\101'就表示ASCII值是101的那个字符，'\XAB'也是一个合法字符常量。
    例题
    下面字符常量中哪些是合法的哪些是非法的
    'A'  合法
    '\'  非法
    '65' 非法，一对单引号里只能引一个字符
    65  合法，相当于是'A',因为'A'存储和运算的时候就是其ASCII值
    '\0XAB' 非法，这里不能用0X开头
    '\XAB' 合法
    "a"  非法，双引号引起来的叫字符串，我们后面会学习到

5.i++与++i的异同
相同点：在执行后的结果是一样的，都使变量i的值自加1。
不同点：执行中i++是先用后加，而++i是先加后用。
先用后加的意思是说i++这个表达式出现在运算式中的时候是先进行运算，而后让变量i的值自加1。先加后用的意思是说++i这个表达式出现在运算式中的时候是先让变量i的值自加1，然后再进行运算
相同点举例int i=3;
i++;
printf("%d",i);

int i=3;
++i;
printf("%d",i);
这两个程序输出的结果都是4，因为i++这个表达式和++i这个表达式并没有参与任何运算，只是作为一条独立语句存在，所以没有差异，执行后变量i的值都变成4

不同点举例
int i=3,x;
x=(i++)*2;
printf("%d   %d",i,x);
结果是4   6

int i=3;
x=(++i)*2;
printf("%d   %d",i,x);
结果是4   8
这两个程序中，表达式i++和表达式++i在程序中参与了运算，所以就必须搞清楚是加前的数据参与运算还是加后的数据参与运算。这时就有了区别：i++由于是先用后加，因此i++表达式的值就是i的值，也就是(i++)*2意味着3*2进行运算，将6赋给x，执行结束后变量i的值就自加1变成4。而++i由于是先加后用，因此i++表达式的值就是i+1的值，也就是(++i)*2意味着4*2进行运算，将8赋给x，执行结束。
所以如果是独立语句的话i++;和++i;没有什么区别，只有i++和++i表达式参与运算了会有差异
我们在程序中尽可能不要出现类似于c=(i++)+(++i);或c=i+++j;等等这样的表达式，因为这样的表达式在不同的编译器中的解释可能不一样，造成程序阅读的困难。可以把它们分步来完成，以上的两个命令可以写成如下形式
a=i++;
b=++i;
c=a+b;

x=i++;
c=x+j;

6.&&运算和||运算的规则
A&&B运算中，若A的值不成立，则不执行B，结果不成立
A||B运算中，若A的值成立，则不执行B，结果成立
这个现象也很好理解，因为A与B进行&&运算时，只有当A和B的值同时都成立的时候结果才能成立，有一方不成立则结果就不成立，若第一方不成立，则后面的部分算与不算已经不能影响结果了，所以就有了这样的规则。而||运算的规则也是一样，只要能提前得到结果的话，则后面的运算就不会发生。
例题：
int a=2,b=3,c=4,d=5,m=2,n=2,k;
k=(m=a>c)&&(n=b<d);
请问执行后变量k,m,n的值
首先执行a>c的结果赋值给m，也就是将0赋值给m，这个赋值表达式的值就是0，参与了&&运算，按照规则,这时候已经可以得到结果了，是0，因此不会执行后面的部分，也就是没有执行将b<d的结果赋值给n因此n的值还应该是其原值，也就是2，所以结果是k是0，m是0，n是2

int i=1,j=2,k;
k=i--||j++;
请问执行后变量k,i,j的值
i---这个表达式参与||运算是先用i的值参与运算(等运算结束后变量i的值会自加1)，因此1是参与||运算的第一方，这样一来根据能提前得到结果，就不执行后面运算的原则，可以知道j++表达式并没有被使用，当然也不存在自加的运算，所以最后的结果是k是1，i是0，j是2

1.类型混合运算中的结果类型是这样规定的
同类型的运算结果一定是该类型
不同类型之间是有一个“靠拢原则”int->long->double<-float（简单点说就是整型和实型运算后的结果是实型）

例题
10/4  结果得2，因为10和4都是整型，所以结果一定也是整型
10.0/4 结果得2.5，因为10.0是实型，和整型运算后的结果是实型

float r=6.2;表示圆的半径的值，求半圆的面积是多少
1/2*3.14*r*r这个表达式是否能计算半圆的面积呢？结果是不能计算，原因是1/2的运算结果是整型，所以是0，然后乘以3.14后结果是0.0（实型的0），往后乘的结果仍然是0.0
1.0/2*3.14*r*r把1改写成1.0这样就可以了，这个例子告诉我们程序中进行除法运算的时候，为了能得到实型的结果，经常要将1写成1.0

2.运算符混合后的运算符优先级
运算符优先级表如下
 

括号	()
单目	!
算术	*  /  % +  -
关系	>  >=  <  <= ==  !=
逻辑	&& ||
赋值	=  +=  -=  *=  /=  %=

我们先说说关于赋值运算的几个规则
a)赋值运算符的左边，只能是一个变量，不能是常量或表达式
   a=a+1;  这个是正确的语句，表示将a+1的值赋值给a
   c+d=a+b;试图将a+b的值赋给表达式c+d的做法是错误的
   92=a+b;试图将a+b的值赋给一个常量也是错误的
b)赋值表达式的值就是所赋的值。也就是说：如果一个赋值表达式参与运算，应该是赋给左边变量的那个值参与运算
   int a=3,x;
   x=(a=7)*5;    (a=7)这个赋值表达式参与了乘法运算，这个表达式的值应该是赋给a的值，也就是7将参与乘法运算，和变量a中原来的值应该没有关系了，所以执行后x中的值是35，而a中的值是7
c)赋值运算符的“右结合性”（“右结合性”的意思是说赋值符号优先级一样的情况下是从右向左进行运算）
   一般“双目运算符”的结合原则是“左结核性”（也就是是说赋值符号优先级一样的情况下是从左向右进行运算）
   例如:  30/3*2 运算过程应该是30/3得到10，然后10再乘以2得20，而不能是先算3*2得6，然后30除以6得5，因为除法和乘法运算优先级一样，这时应该从左向右做运算（“左结合性”）
   而赋值运算是“右结合性”
   int a=5,b=8;
   a=b=10;
   执行中不能解释成让b的值赋给a，然后执行将10的值赋给b。而要解释成10赋给b，然后表达式（b=10）的值再赋给a，也就是要从右向左进行运算。因此执行后a和b的值都是10
   int a=2;
   a=a*=a+=4;
应该这样分析这个表达式的执行过程，式子中有三个运算符，=、*=、+=都是赋值运算，优先级是一样的，因此我们应该按照“右结合性”也就是从右向左进行计算，首先执行a+=4，也就是a=a+4;把a+4的值赋给a这样一来a的值就变成了6，而a+=4这个赋值表达式的值也就是所赋的值，也是6，所以整个表达式变成a=a*=6;接着再执行a*=6，也就是a=a*6;把a乘以6的值赋给a这样一来a的值就变成了36，而a*=6这个赋值表达式的值就是所赋的值36，然后做最后一次赋值a=36，所以最终a变量里的值就是36

例题：
根据给定表达式的值写出其结果
   int a=2,b=3,c=4,d=5;
   a+d<=b+c||a<c&&!(d>a)
   这个表达式的计算过程中首先要计算优先级最高的（）和“单目”运算符！，d>a的结果是1，而！1的结果是0，得到如下表达式
   a+d<=b+c||a<c&&0
   到了都是“双目”运算符的时候就要找运算符优先级高的进行运算
   找其中的算术运算符进行运算，也就是两个+运算，运算后得到如下表达式
   7<=7||a<c&&0
   找到其中的关系运算符进行运算，也就是<=和<运算，运算后得到如下表达式
   1||1&&0
   逻辑运算中&&运算的优先级高于||所以，首先执行&&运算，运算后得到如下表达式
   1||0
   结果得1

根据数学表达式写出C语言表达式
   float a,b,c,d;
   a*b/2*c*d  这个表达式并不能表示上述数学表达式的值，因为计算机执行时是从左向右依次执行
   a*b/2/c/d  这个表达式可以表示上述数学表达式
   (1/2)*a*b/c/d 这个表达式不能表示，原因是（1/2）的结果是0，而不是0.5。如果将1写成1.0则可以正确表示
   (a*b)/(2*c*d) 这个表达式是可以的
   结论：在将数学表达式写成C语言表达式的过程中要善于利用（）进行表示。