暑期培训总结日记#NO.4

C语言 continue

一、跳转语句：

goto

可以在函数内任意跳转，标签名：（标签名后加:）标签名所在函数顶格   ... goto 标签名；

它可能会破坏已经设计好的分支或者循环结构，因此绝大多数公司禁止使用goto。禁用goto，但是在驱动编程时特别适合处理异常。

练习1：计算N的阶乘（不用循环）

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num = 0,i=1,result = 1;
    printf("Please input a number:\n");
    scanf("%d",&num);
LP:
    result=i*result;
    i++;
    if(i<=num)
    {   
        goto LP; 
    }   
    printf("%d的阶乘为%d",num,result);
    return 0;
}

break

1.在switch中关闭case执行开关

2.循环中跳出循环，只能跳出当前一层循环

Continue

结束本次循环，进入下一次循环

return

1.结束函数的执行，程序跳转回函数调用的地方继续执行2.返回一个数据给函数的调用者

二、数组：

什么是数组：变量的组合，是一种批量定义类型相同的变量的方式

定义：  类型名  数组名[数值（最多存储的数量）]   int array≈arr [5]；  使用时通过数组名[下标]，下标从0开始！范围：0~数量-1。遍历：与for循环配合，使用循环变量当作数组下标。

数组初始化：类型名  数组名[数值（最多存储的数量）]={1,2,3,4...}；两个括号中只能省略一个

1.因为数组的值默认是随机的，一般为了安全起见要对数组进行初始化

2.初始化的数据过多，编译器会产生警告并丢弃多余的数据

3.初始化数据不够，编译器会末尾补0

4.初始化时数据可以省略，只写大括号，相当于给所有成员初始化为0

5.这种初始化语法只能在定义数组时使用，并且只能逐个赋值，不能整体赋值

6.初始化时数组的长度（数量）可以省略，编译器会自动统计初始化大括号中的数据的个数并告诉数组确定数组的数量，一旦数组的长度确定，后面无法改变

7.sizeof(arr)/sizeof(arr(0))万能公式，计算数组个数：总字节数/单个成员字节数=成员个数

练习2：定义一个长度为10的数组并初始化，计算最大值最小值和平均值

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10},i=0,min=0,max=0;
    double ave=0;
    max=arr[0];
    min=arr[0];
    for(i=0;i<9;i++)
    {   
        if(arr[i+1]>max)
        {
             max=arr[i+1];
        }
        if(arr[i+1]<min)
        {
            min=arr[i+1];
        }
        ave=ave+arr[i];
    }   
    printf("max=%d,min=%d,average=%lf",max,min,(ave+arr[9])/10);
}

 

练习3：定义一个长度为10数组并初始化，进行升序排序

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int arr[10]={2,4,1,3,5,6,9,10,8,7},res[10]={},min=0,i=0,j=0,temp=0;
    min=arr[0];
    for(j=0;j<9;j++)
    {   
        min=j;
        for(i=j+1;i<10;i++)
        {
            if(arr[min]>arr[i])
            {
                min=i;
            }
        }
        temp=arr[j];
        arr[j]=arr[min];
        arr[min]=temp;
    }   
    for(j=0;j<10;j++)
    {   
        printf("%d ",arr[j]);
    }   

    
    
}

/* int arr ~~
   for(int i=0;i<9;i++)
   {
       for(int j=i+1;j<10;j++)
       {
           if(arr[i]>arr[j])
           {
               int temp =arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
           }
       }
   }
   for()     输出结果
    */

 

三、数组越界：

为了程序的编译运行效率，编译器不去检查数组下标（科学家觉得不会越界，是我们太菜了）

数组越界的后果：

1.段错误（核心已转储）

2.一切正常

3.脏数据

总结：使用数组的过程中时刻注意不要越界

练习4：定义一个长度为10数组并初始化（数组不会重复），找出第二大的数，不允许排序

#include <stdio.h>
int main(int argc,const char* argv[])
{
    int arr[10]={10,9,2,3,1,5,4,6,8,7},temp=0,max=0;
    max=arr[0];
    for(int i = 1;i<10;i++)
    {   
        if(max<arr[i])
        {
            max=arr[i];
            temp=i;
        }
    }   
    if(temp==0)
    {   
        max=arr[1];
    }   
    else
    {   
    max=arr[0];
    }   
    for(int j = 1;j<10;j++)
    {   
        if(temp==j)
        {
            continue;
        }
        if(max<arr[j])
        {
            max=arr[j];
        }
    }   
    printf("%d",max);
}
/*
    int arr{}~~~
    int max_1=arr[0],max_2=arr[0];
    for(int i=1;i<10;i++)
    {
        if(max_1<arr[i])
        {
            max_2=max_1;
            max_1=arr[i];
        }
        else if(max_2<arr[i])
        {
            max_2=arr[i];
        }
    }
    printf("%d %d\n",max_1,max_2);
    //若第一个就是最大，加步骤比较去排除，代码略
*/

 

四、二维数组：

一维数组相当于把变量排成一排，通过编号访问；二维数组相当于把变量排成一个矩阵，通过行号和列号访问。

定义： 类型  数组名 [行数][列数]；int arr[3][5]；

使用：数组名[行下标][列下标]；下标依然从0开始 遍历：一般需要与双层for循环配合，可外层循环负责遍历行，内层循环负责遍历列

int arr[x][y];

for(int i=0;i<x;i++)

{

for(int j=0;j<y;j++)

{

printf(“%d ”,arr[i][j]);

}

printf(“\n”);

}

初始化：类型 数组名[行数][列数]={{第一行},{第二行},{第三行}...}

练习5：定义一个五×五二维数组并初始化，找出其中最大值的左坐标

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int arr[5][5]={{20,22,7,8,5},{19,94,6,18,5},{20,0,10,26,2},{20,1,5,14,6},{26,52,0,13,14}},temp1 = 0,temp2 = 0,max=0;
    max=arr[0][0];
    for(int i=0;i<5;i++)
    {   
        for(int j =0;j<5;j++)
        {
            printf("%2d ",arr[i][j]);
            if(max<arr[i][j])
            {
            max=arr[i][j];
            temp1=i;
            temp2=j;
            }
        }
        printf("\n");
    }   
    printf("横坐标为%d纵坐标为%d",temp1,temp2);
}

 

五、变长数组：

定义数组时，使用变量作为数组的长度，在代码编译期间，数组的长度是不确定的，当运行到数组的定义语句时，数组的长度才最终确定下来，这种数组称为变长数组。

优点：可以根据实际情况来确定数组长度，以此节约内存空间

缺点：不能进行初始化，初始化发生在程序编译期间，而数组的长度在程序运行时才确定

注意：数组长度一旦确定后续便无法改变

练习6：输入两个正整数m（1~6）、n（1~6），然后输入数组 arr[m][n]各个元素的值，然后统计各元素之和、非0元素个数、计算出所有元素的平均值、统计大于平均值的元素个数

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int m = 0,n = 0,count = 0,bignum = 0,length = 0;
    double ave = 0,sum = 0;
    printf("请输入数组行列数\n");
    scanf("%d%d",&m,&n);
    printf("请输入各行各列元素\n");
    double arr[m][n];
    length=sizeof(arr)/sizeof(arr[0][0]);
    for(int i = 0;i<m;i++)
    {   
        for(int j = 0;j<n;j++)
        {
            scanf("%lf",&arr[i][j]);
            sum=arr[i][j]+sum;
            if(arr[i][j]!=0)
            {
                count++;
            }
        }
    }   
    ave=sum/length;
    for(int i = 0;i<m;i++)
    {   
        for(int j = 0;j<n;j++)
        {
            if(ave<arr[i][j])
            {
                bignum++;
            }
        }
    }   
    printf("每个元素之和为%lf，非零元素个数为%d,平均值为%lf，大于平均值的个数为%d",sum,count,ave,bignum);
}

 

作业：

1.定一个5×5的二维数组并初始化（自己初始化），找出最小值的坐标，计算出最小值周围一圈数据的和

#include<time.h>
#include<stdio.h>
#include<stdlib.h>
int main(int argc,const char* argv[])
{
    srand(time(0));
    int arr[5][5]={};
    int i=0,j=0,temp1=0,temp2=0,min=0,temp=0,sum=0,judge=1;
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            int a=rand()%100;
            arr[i][j]=a;
            printf("%3d ",arr[i][j]);
        }
        printf("\n");
    }
    min=arr[0][0];
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            if(min>arr[i][j])
            {
                min=arr[i][j];
                temp1=i;
                temp2=j;
            }
        }
    }
    printf("第一个最小值在第%d行第%d列\n",temp1+1,temp2+1);
    // 还可以把最小值周围当作一个3*3数组，判断边界条件直接加最后减去中间最小值
    if(temp1-1<5 && temp1-1>=0)
    {
        sum=sum+arr[temp1-1][temp2];
        if(temp2-1<5 && temp2-1>=0)
        {
            sum=sum+arr[temp1-1][temp2-1]+arr[temp1][temp2-1];
            judge=0;
        }
        if(temp2+1<5 && temp2+1>=0)
        {
            sum=sum+arr[temp1-1][temp2+1]+arr[temp1][temp2+1];
            judge=0;
        }
    }
    if(temp1+1<5 && temp1+1>=0)
    {
        sum=sum+arr[temp1+1][temp2];
        if(temp2-1<5 && temp2-1>=0)
        {
            sum=sum+arr[temp1+1][temp2-1]+arr[temp1][temp2-1]*judge;
        }
        if(temp2+1<5 && temp2+1>=0)
        {
            sum=sum+arr[temp1+1][temp2+1]+arr[temp1][temp2+1]*judge;
        }
    }
    printf("最小值周围一圈数的和是%d\n",sum);
    return 0;
}
/*
    int arr[5][5]={
        shu ju }
    int min=arr[0][0],min_x=0,min_y=0;
    for(int i=0;i<5;io++)
    {
        for(int j=0;j<5;j++)
        {
            if(arr[i][j]<min)
            {
                min=arr[i][j];
                min_x=i;
                min_y=j;
            }
        }
    }
    int sum=0;
    if(min_x>0) sum+=arr[min_x-1][min_y];
    if(min_x<4) sum+=arr[min_x+1][min_y];
    if(min_y>0) sum+=arr[min_x][min_y-1];
    if(min_y<4) sum+=arr[min_x][min_y+1];
    if(min_x>0 && min_y>0) sum+=arr[min_x-1][min_y-1];
    if(min_x>0 && min_y<4) sum+=arr[min_x-1][min_y+1];
    if(min_x<4 && min_y>0) sum+=arr[min_x+1][min_y-1];
    if(min_x<4 && min_y<4) sum+=arr[min_x+1][min_y+1];
    printf(..);
*/

2.输入N,显示N层杨辉三角：

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int N = 0,L = 0;
    printf("Please input a N\n");
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
    {   
        L=L+i;
    }   
    int arr[N][L];
    for(int i=0;i<N;i++)
    {   
        for(int j=0;j<L;j++)
        {
            arr[i][j]=0;
        }
    }   
    arr[0][0]=1;
    for(int i=1;i<N;i++)
    {   
        for(int j=0;j<=i;j++)
        {
            if(j==0||j==i)
            {
                arr[i][j]=1;continue;
            }
            arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
        }
    }   
    for(int i=0;i<N;i++)
    {   
        for(int j=0;j<L;j++)            //j<=i 更为简便
        {
            if(arr[i][j]==0)
            {
                break;
            }
            printf("%4d ",arr[i][j]);
        }
        printf("\n");
    }   

}

 

3.输入一个日期（yyyy-mm-dd），计算该日期距离1年1月1日过了多少天

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int run=0,iyear=0,imonth=0,iday=0,leapyear=0,simpleyear=0,totaldays=0;
    printf("请输入一个年月日，例如年-月-日\n");
    scanf("%d-%d-%d",&iyear,&imonth,&iday);
    for(int i=1;i<=iyear;i++)
    {   
        if (i%4==0 && i%100!=0)
        {
            leapyear++;
            if(i==iyear)
            {
                leapyear=leapyear-1;
                run=1;
            }
        }
        else if (i%400==0)
        {
            leapyear++;
            if(i==iyear)
            {
                leapyear=leapyear-1;
                run=1;
            }
        }                                 //(y%4==0 && y%100!=0 || y%400==0)
        else
        {
            simpleyear++;
            if(i==iyear)
            {
                simpleyear=simpleyear-1;
            }
        }
    }   
    if(run==0 && imonth==2 && iday==29)
    {   
        printf("这一年不是润年\n");
        return 0;
    }   
    if(imonth>12 || iday>31)
    {   
        printf("您输入的日期有误\n");
        return 0;
    }   
    if(imonth==2 && iday>29)
    {   
        printf("您输入的日期有误\n");
        return 0;
    }
    totaldays=leapyear*366+simpleyear*365;
    for(int i=1;i<imonth;i++)
    {
        if(i==2 && run)
        {
            totaldays=totaldays+29;
        }
        else if(i==2 && run==0)
        {
            totaldays=totaldays+28;
        }
        else if(i==1 || i==3 || i==5 || i==7 || i==8 || i==10 || i==12)
        {
            totaldays=totaldays+31;
        }
        else
        {
            totaldays=totaldays+30;
        }
    }
    totaldays=totaldays+iday-1;
    printf("该日期距离1-1-1过了%d天\n",totaldays);
}