数组及相关练习

 

数组：使用一段连续的存储空间存储类型相同的构造类型

构造类型：可以分割（数组，结构体，共用体）

1. 一维数组

一维数组：使用一个下标表示的数组

int arr【】

格式：存储类型 数据类型 数组名[常量表达式]

*解析

*存储类型：auto/static/exterm/register/const/volatie

*数据类型：基类型，构造类型，空类型，指针

*数组名：满足命名规范

*【】：是数组的标志

*常量表达式：表示数组元素的个数，定义时不为0，不为空，不为小数，初始值不为变量

int arr[5]--->auto int arr[5] arr[5]的类型是int [5]

int arr[0] error 不报错

int arr[] error 报错

int arr[5.5] error

int n=5;int arr[n]; 正确

int n=5;int arr[5]={1,2,3,4,5}； error

一维数组的定义及初始化/赋值

一维数组的全部初始化

int arr[5]={1,2,3,4,5};

一维数组的部分初始化：剩余元素使用0填充

int arr[5]={1,2};

int arr[5]={0};//对数组清0

一维数组的单个赋值

int arr[5];//默认随机数

arr[0]=1;

arr[1]=2;

arr[2]=3;

其他未被赋值的值默认是随机值

省略数组长度初始化

int arr[]={1,2,3,4,5};//数组长度默认是实际元素的个数

计算数组长度：

sizeof(arr)/sizeof(int)--->sizeof(arr)/sizeof(arr[0])

memset函数

功能：实现对数组清0和-1（内存清0）

格式：

#include <string.h>

void *memset(void *s, int c, size_t n);

参数：

void *s：表示数字变量名

int c：清的值

size_t n：数组字节大小

size_t--->#define size_t unsigned long(64位情况下）

在64位操作系统中size_t表示unsigned long类型

size_t--->#define size_t unsigned int(32位情况下）

在32位操作系统中size_t表示unsigned int类型

使用格式：

int arr[5];

memset(arr,0,sizeof(arr));

bzero函数

功能：实现对数组清0

格式：

#include <strings.h>

void bzero(void *s, size_t n);

参数：

void *s：表示数字变量名

size_t n：数组字节大小

使用格式：

int arr[5];

bzero(arr,sizeof(arr));

数组的错误赋值

int arr[5];

arr[5]={1,2,3,4,5};//不支持拐弯赋值

int arr[5];

arr={1,2,3,4,5};//不支持拐弯赋值

int arr[5]={1,2,3,4,5,6,7,8};//不能超出范围

数组的引用

数组的下标从0开始，n元素的数组，下标[0,n-1]

int arr[5]；0-4

数组元素的引用

int arr[5]={1,2,3,4,5};

arr[0]==1;

arr[1]==2;

arr[2]==3;

数组的循环引用

练习：定义一个存储5个浮点数的数组，循环输入，循环输出，计算和

数组的越界访问

int arr[5];

printf("%d\n",arr[5]);//arr[]的下标为0-4所以arr[5]越界

*如果越界访问的内存没有被占用，可以访问，访问结果位随机值

*如果越界访问的内存被占用，存储的是不重要数据，则可以访问，访问结果为随机值

*如果越界访问的内存被占用，存储的是重要数据，则不可以访问，段错误（访问了不该访问的内存区间）

一维数组的地址

数组名表示数组的首地址，也就是第一个元素的地址

int arr[5];

=/- ？-**arr--->&arr[0]-*/+ 地址的打印：

地址的加减运算，加减的是字节大小

*数组的内存是连续的

*地址编号：由用户层+内核+硬件层组成

一维数组的练习：

输入一个key，输入一个存储5个整数的数组，问key出现了几次

定义数组并初始化12 34 2 5 7 3，输出最大，最小值

定义数组并初始化12 34 2 5 7 3，输出第二大的值（把第二大值赋值为最小值）

输入n个整数，按冒泡排序

冒泡排序：对一个待排列序列，依次拿前一个与后一个进行比较，如果前一个大于后一个则进行交换

空间复杂度：O（1）

时间复杂度：O（n^2）

输入n个整数，实现简单选择排序

简单选择：对于一个待排序列来说，默认第一个数为最值，若比最值大（小）则交换

直接交换最值

改下标再交换最值

1. 二维数组（多维数组）

二维数组：使用两个下标表示的数组

int arr 【】【】

格式：存储类型 数据类型 数组名[常量表达式1][常量表达式2]

解析

*存储类型：auto/static/exterm/register/const/volatie

*数据类型：基类型，构造类型，空类型，指针

*数组名：满足命名规范

*【】：是数组的标志

*常量表达式1：第一维，表示行，在初始化时可有可无

*常量表达式2：第二维，表示列，必须存在

int arr[3][5];//三行五列，存储了15个整数，占60个字节，类型：int[3][5]

二维数组的定义

二维数组的初始化及赋值

二维数组的全部初始化

int arr[2][3]={1,2,3},{4,5,6};//按行初始化

int arr[2][3]={1,2,3,4,5,6};//按列初始化

int arr[][3]={1,2,3,4,5,6};//按列初始化时，可以省略第一维，计算机不扫描第一维

二维数组的部分初始化（剩余元素填充0）

int arr[2][3]={1,0,0},{4,5,0};//按行初始化

int arr[2][3]={1,2,3,0,0,0};//按列初始化

int arr[][3]={1,2,0};//按列初始化时，可以省略第一维，计算机不扫描第一维

int arr[][3]={{1},{2}};//2行

二维数组的引用

因为数组下标从0开始，所以m行n列的数组，行小标范围是[0,m-1]，列下标范围是[0,n-1]

int arr[m][n];

最后一个元素是arr[m-1][n-1]。

二位数组的元素：

arr[0][0]--->第一行第一列的元素

arr[i][j]--->第（i+1）行（j+1）列的元素

计算行：sizeof(arr)/sizeof(arr[0])

计算列：sizeof(arr[0])/sizeof(arr[0][0])

循环输入输出一个二维数组并计算平均值

第一题

    float sum=0;
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            scanf("%d",&arr[i][j]);
            printf("arr[%d][%d]=%d\n",i,j,arr[i][j]);
        }


    }
    int max=arr[0][0],min=arr[0][0];
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            if(max<arr[i][j])
            {
                max=arr[i][j];
            }
        }

    }
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            if(min>arr[i][j])
            {
                min=arr[i][j];
            }
        }

    }
    printf("max=%d min=%d\n",max,min);
    return 0;
}

第二题

#include <stdlib.h>
#include <math.h>
int main(int argc, const char *argv[])
{
    int num;
    printf("输入一个成绩\n");
    scanf("%d",&num);
    switch(num/10)
    {
    case 10:printf("A\n");break;
    case 9:printf("A\n");break;
    case 8:printf("B\n");break;
    case 7:printf("C\n");break;
    case 6:printf("D\n");break;
    default:printf("其他错误\n");break;              
    }
    return 0;
} 

第三题

#include <math.h>
int main(int argc, const char *argv[])
{
    int a,b,c;
    for(a=0;a<=100;a++)
    {
        for(b=0;b<=100;b++)
        {
            for(c=0;c<=100;c+=3)
            {
                if (100==a*5+b*3+c/3)                               
                {
                    printf("%d只鸡翁%d只鸡母%d只鸡雏\n",a,b,c);
                }
            }
        }
    }
        
    return 0;
} 

第四题 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, const char *argv[])
{
        int i,j;
    
    for(i=1;i<=9;i++)
    {
        for(j=1;j<=i;j++)
        {
            printf("%d*%d=%d\t",i,j,i*j);
        }
        printf("\n");
    }
    return 0;

}

第五题 

{
    int i,j;
    for(i=1;i<=7;i++)
    {
        for(j=1;j<=i;j++)
        {
            printf("_");
        }
        for(j=2;j<=i;j++)
        {
            char num;
            num='F'-j+2;                              
            printf("%c",num);
        }
        putchar(10);
    }
    return 0;
}

第六题 

    {
        scanf("%d",&arr[i]);
    }
    int max=0,min=0;                                               
    for(int j=0;j<n;j++)
    {
        if (arr[max]<arr[j])
            max=j;
        if (arr[min]>arr[j])
            min=j;
    }
    int t;
    t=arr[max];
    arr[max]=arr[min];
    arr[min]=t;
    for(int l=0;l<n;l++)
    {
        printf("%d",arr[l]);
    }
    putchar(10);

    return 0;
}

第七题 

    for(int j=0;j<k;j++)
    {
        for(int m=0;m<n;m++)                            
        {
            int q,p;
            p=(m+1)%n;
            q=arr[0];
            arr[0]=arr[p];
            arr[p]=q;
        }

    }
    for(int o=0;o<n;o++)
    {
        printf("%d",arr[o]);
    }
    putchar(10);

    return 0;
}

第八题 

                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
        for(int w=0;w<len;w++)
        {
            printf("%d ",arr[w]);
        }
        putchar(10);
    }
    else if (1==flag)
    {
        for(int e=1;e<len;e++)
        {
            int min=e-1;
            for(int r=e;r<len;r++)
            {
                if (arr[min]>arr[r])
                {
                    min=r;
                }

            }
            if(min!=e-1)
            {
                int t;
                t=arr[min];
                arr[min]=arr[e-1];                                                                                 
                arr[e-1]=t;
            }
        }
        for(int y=0;y<len;y++)
        {
            printf("%d ",arr[y]);
        }
        putchar(10);
    }


    return 0;
}

第九题 

    int len=sizeof(arr)/sizeof(arr[0]);
    int max=arr[0],min=arr[0];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&arr[i]);
    }
    int j;
    for(j=0;j<len;j++)
    {
        if(max<arr[j]) 
            max=arr[j]; 
        if(min>arr[j]) 
            min=arr[j];
    }
    int second=min;
    for(int k=0;k<len;k++)
    {
        if(arr[k]==max)
            continue;
        if(second<arr[k])
            second=arr[k];
    }
    int sum,o;
    sum=max+second;
    o=max-min;
    printf("最大和=%d最大差=%d\n",sum,o);
    return 0;
}

第十题 

18

第十一题 

g

第十二题 

3

第十三题 

-1