数组

一.一维数组的创建和初始化

1.数组的创建

数组是一组相同元素的集合。数组的创建方式：

type_t arr_name [const_n];
   type_t 是指数组的元素类型
   arr_name 数组名
   const_n 是一个常量表达式，用来指定数组的大小

数组创建的实例：

int arr[10];

char arr[10];

但这个不正确：

int count=10;
int arr[count];

注：数组创建，[ ]中要给一个常量才可以，不能使用变量

2.数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）

不完全初始化：

剩下的元素默认初始化为0

int arr1[10]={1,2,3};

char arr2[5]={'a','b'};

char arr3[5]="ab";//双引号放字符串--a b \0 0 0

完全初始化：

char arr[5]={1，2，3，4，5}

如果[  ]没有放常量 则必须对该数组进行初始化

char arr[]="abcdef";

3.一维数组的使用

对于数组的使用我们之前介绍了：[ ]，下标引用操作符。它其实就是数组访问的操作符。

对数组的打印方法：

#include<stdio.h>
#include<string.h>
int main()
{
  char arr[]="abcdef";//[a][b][c][d][e][f][\0]
  //printf("%s\n",arr);字符串
  int i=0;
  for(i=0;i<strlen(arr);i++)
  {
    printf("%c ",arr[i]);
  }
  return 0;
}

总结：

1.数组是使用下标来访问，下标是从0开始

2.数组的大小可以通过计算得到

int arr[10]
int sz=sizeof(arr)/sizeof(arr[0])

4.一维数组在内存中的储存

#include<stdio.h>
int main()
{
  int arr[]={1,2,3,4,5,6,7,8,9,10};
  int sz=sizeof(arr)/sizeof(arr[0]);
  int i=0;
  for(i=0;i<sz;i++)
  {
    printf("arr[%d]=%p\n",i,&arr[i]);//打印每个元素的地址
    //数组在内存中的布局
  }
  return 0;
}

%p是打印取地址的  ；&arr[i]的&是取地址符号

发现：相邻的两个整型类型中间都相差4个字节

结论：数组在内存中是连续存放的

二.二维数组的创建和初始化

1.二维数组的创建

 arr[ 行 ][ 列 ]

int arr[3][4]

char arr[3][4]

double arr[2][4]

2.二维数组的初始化

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

注：还可以把一行一行的整体看出一个一维数组 这个整体的一维数组可以用{ }进行部分的打印

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

注：可以省略行 但不能省略列

int arr[][4]={{2,3},{4,5}};//这里就是两行 因为{}{}里面的{2,3}{4,5}分别代表一行

3.二维数组的使用

二维数组也是通过下标的方式使用

#include<stdio.h>
int main()
{
  int arr[3][4]={{1,2,3},{4,5}};
  int i=0;
  for(i=0;i<3;i++)//行
  {
    int j=0;
    for(j=0;j<4;j++)
    {
      printf("%d ",arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

类似乘法口诀表的打印方法

4.二维数组在内存中的储存

#include<stdio.h>
int main()
{
  int arr[3][4]={{1,2,3},{4,5}};
  int i=0;
  for(i=0;i<3;i++)//行
  {
    int j=0;
    for(j=0;j<4;j++)
    {
      printf("arr[%d][%d]=%p\n",i,j,&arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

数组作为函数参数

往往我们在写代码的时候，会将数作为参数传个函数，比如：我要实现一个冒泡排序（这里要讲算法思想）函数将一个整型数组排序。那我们将会这样使用函数：

冒泡排序

当数组传参的时候，实际上只是把数组的首元素的地址传过去了

所以即使在函数传参部分写成数组的形式：int arr[ ]，表示的依然是一个指针：int * arr

（一套）：

一套冒泡排序可以找到一个最大值

举例：

#include<stdio.h>
void bubble_sort(int arr[],int sz)//排完序就可以了 所以不需要返回值
{
  //确定冒泡排序的趟数
  //确定多少个元素（n个元素需要n-1趟）
  int i=0;
  for(i=0;i<sz-1;i++)
  {
    //每一趟冒泡排序
    int flag=1;
    //假设这趟要排序的数组已经有序了

    int j;
    for(j=0;j<sz-1-i;j++)//比较的对数
    {
      if(arr[j]>arr[j+1])
      {
        int tmp=arr[j];
        arr[j]=arr[j+1];
        arr[j+1]=tmp;
        flag=0;//本趟排序的数据其实是不完全排序
      }
    }
    if(flag==1)
    {
      break;
    }
  }
}
int main()
{
  int arr[]={9,8,7,6,5,4,3,2,1,0};
  int i=0;
  int sz=sizeof(arr)/sizeof(arr[0]);
  //对arr进行排序 拍成升序
  bubble_sort(arr,sz);
  ///arr是数组 数组传参传的是第一个元素的地址
  //冒泡排序函数
  for(i=0;i<sz;i++)
  {
    printf("%d ",arr[i]);
  }
  return 0;
}

数组名是什么

#include <stdio.h>
int main()
{
  int arr[10]={1,2,3,4,5};
  printf("%p\n",arr);
  printf("%p\n",&arr[0]);
  printf("%d\n",*arr);
  return 0;
}

结论：数组名是数组首个元素的地址（有两个例外）

例外：

1.sizeof（数组名），计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组，单位是字节

2.&数组名，取出的是数组的地址 。&数组名，数组名表示整个数组