数组啊啊啊

数组啊啊啊

int a[10]//定义的10个数组元素下标是从0-9的

数组元素的下标都是从0开始的

希望下标从1-10  int a【11】然后忽略第一个元素

数组
一维数组的创建和初始化
一组由相同类型元素组成的集合
为什么要用数组呢
开辟一个空间一次性存放一组数
数组：一维数组，二维数组，三维数组和多维数组

一维数组的创建
int a【10】；
一维数组的标准格式：type_t arr_name [const_n]
const可以定义一个常量
type_t：数组的元素类型
arr_name：数组的名字
[const_n]：数组的大小，也就是元素的个数，const_n，产量表达式
int arr[10];//变长数组

一维数组初始化
int mian()
{
     int arr[8]={1,2,3,4,5,6,7,8};//完全初始化
     int arr2[8]={1,2,3,4,5};//不完全初始化，后续会补0
     char arr3[8]={'1','2','3'};//不完全初始化，补0
     int arr4[]={1,2,3,4,5};//会根据给的元素确定常量的值（会自动确定）

     char ch1[5]={'m','j','u'};
     char ch3[5]={"mju"};//ch1和ch3结果相同
     char ch2[]={'m','j','u'};//mju(后面没有/0不算结束，程序会一直往后找到/0为止)
     char ch4[]={'m','j','u'};//mju/0
双引号代表字符串，单引号代表字符
     printf("%sn",ch2);//随机值
     printf("%sn",ch4);//mju
在内存中，字符串的结束符是/0

strlen--string 
printf("%dn",strlen(ch2));//随机值
printf("%dn",strlen(ch4));//3
printf("%dn",strlen(ch1));//3
printf("%dn",strlen(ch3));//3 字符串就是mju三个
printf("%dn",sizeof(ch3)/sizeof(ch3[0]));//5
sizeof(ch3[0])：数组中一个元素占内存的大小
总个数除以一个的
printf("%dn",sizeof(ch3)；//5  int：20（int一个占四个字节）
strlen求字符串大小，不包括
sizeof求的是数组占内存的字节数
     return 0;
}

一维数组的使用
下标 *** 作符[],实际上是数组访问 *** 作符
int main()
{
    int i=0;
    int arr[10]={0};
    for()i=0;i<10;i++
    {
        arr[i]=i;
        for(i=0;i<10;i+)
        {
            printf("%d",arr[i]);
        }
    }
}
数组在内存中的存储方式
int main()
{
    int arr[10]={0};
    int i=0;
    int sz=sizeof(arr)/sizeof(arr[0]);
    for(i=0;i     {
        printf("%pn",&arr[i]);//%p是指针 &arr[i]是数组元素的地址 
    }
} 
//数组在内存中是连续存放的
//随着下标的增长，地址也是由低到高 

数组在内存中的存储方式
int main()
{
    int arr[10]={0};
    int i=0;
    int sz=sizeof(arr)/sizeof(arr[0]);
    for(i=0;i     {
        printf("%pn",&arr[i]);//%p是指针 &arr[i]是数组元素的地址 
    }
} 
//数组在内存中是连续存放的
//随着下标的增长，地址也是由低到高 

二维数组
int arr[2][3];//2行3列 
char arr[3][5];//3行5列  int和char定义就是字符类型的区别 

二维数组初始化
int arr[10]={0};
int arr1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
int arr2[3][4]={1,2,3,4,5,6,7,8};//1 2 3 4   5 6 7 8   0 0 0 0 
int arr3[3][4]={{1,2},{3,4},{5,6}};//1 2 0 0     3 4 0 0      5 6 0 0
二维数组行可以不写，列一定要写
int arr4[][4]={{1,2},{3,4},{5,6}};

二维数组的使用：
通过下标的方式
int main()
{
    int arr1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    int i=0;
    int j=0;
    for(i=0;i<3;i++)//i控制行
    {
        for(j=0;j<=4;j++)
        {
            printf("%d",arr[i][j]);
        }
    } 
    return 0;
} 

二维数组在内存中的存储
int main()
{
    int arr1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    int i=0;
    int j=0;
    
    for(i=0;i<3;i++)
    {
        for(j=0;j<4;j++)
        {
            printf("&arr[%d][%d]=%pn",i,j,&arr1[i][j]);//取二维数组中国，第i行第j个的地址 
        }
    }
    return 0;
} 

数组作为函数的参数
冒泡排序
9,8,7,6,5,4,3,2,1
8,9,7,6,5,4,3,2,1
8,7,6,9,5,4,3,2,1
...... 
8,7,6,5,4,3,2,1,9
一共比9-1轮
for(9-i-1)

冒泡排序函数
void bubble_sort(int arr[],int n)//形参arr[]本质也是指针 
{
    int sz=sizeof(arr)/sizeof(arr[0]);
    int i=0;
    int j=0;
    int t=0;
    for(i=0;i     {
        for(j=0;j         {
            if(arr[j]>a[j+1])
            {
                t=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=t;
                printf("%d %d",arr[j],arr[j+1]);
            }
            
        }
    }
}

int main() 
{
    int arr[]={9,8,7,6,5,4,3,2,1};
    intsz=sizeof(arr)/sizeof(arr[0]); //sizeof是一个 *** 作符，不是一个函数 
    //需要定义一个函数实现冒泡排序
    bubble_sort(arr,sz); //直接拿数组名称出来是一个指针，(arr) 数组名作为实参进行传参的时候，传递的实际上是数组的首元素地址 
    printf("%dn",*arr);//首元素的值
    printf("%pn",arr);//只有一个地址名取到的是首元素地址 
    printf("%pn",&arr);//在地址名前加一个取地址符&，取到的是整个数组的地址
    printf("%pn",arr+1);//第二个元素的地址
    printf("%pn",&arr+1);//整个数组加1是下一个数组的地址 
    printf("%pn",&arr[0]);
}
//数组有两种情况
1.sizeof（数组名），计算的就是整个数组的大小
2.&数组名，取出来的是整个数组的地址
3.数组名作为参数传递的时候，数组名就是数组的首元素地址 

数组越界
int main ()
{
    int a[10]={0};
    for(int i=0;i<=10;i++)
    {
        printf("%d",a[i]);//[]里最大到9，但是这里写的函数i可以放10,这就是数组越界 
    }
    return 0; 
}
数组下标不能小于0或（元素个数-1）