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

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

数组类型     数组名[const_n]

const_n必须为一个常量，不能使用变量

#include 
#include 
 
int main()
{
   int arr1[10] = {1,2,3}; // 不完全初始化，剩下的元素默认初始化为0
   char arr2[5] = {'a',98};
   char arr3[5] = "ab";
   char arr4[] ="abcdef";
   printf("%d\n",sizeof(arr4)); // 7 有一个'\0'结束符
   printf("%d\n",strlen(arr4)); // 6，strlen求字符串长度，遇到'\0'结束
   return 0;
}

• strlen        求字符串长度，需要引入头文件string.h
• sizeof        计算变量、数组、类型的大小，单位为字节

#include 
#include 
 
int main()
{
   char arr1[] = "abc";
   char arr2[] = {'a', 'b', 'c'};
   printf("%d\n", sizeof(arr1)); // 4
   printf("%d\n", sizeof(arr2)); // 3
   printf("%d\n", strlen(arr1)); // 3
   printf("%d\n", strlen(arr2)); //随机数，因为没有结束符'\0'
   return 0;
}

2.一维数组的使用

下标引用操作符        [ ]

#include 
#include 
 
int main()
{
   char arr1[] = "abc"; // [a] [b] [c] [\0]
   printf("%c\n", arr1[3]);
   return 0;
}

• 数组是使用下标来访问的，下标是从0开始
• 数组的大小计算

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

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

#include 
#include 
 
int main()
{
   int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   int sz = sizeof(arr) / sizeof(int);
   int i = 0;
   for (i = 0; i < sz; i++)
      printf("&arr[%d] = %p\n", i, &arr[i]);
   return 0;
}

输出结果： 

&arr[0] = 0000007311bff930
&arr[1] = 0000007311bff934
&arr[2] = 0000007311bff938
&arr[3] = 0000007311bff93c
&arr[4] = 0000007311bff940
&arr[5] = 0000007311bff944
&arr[6] = 0000007311bff948
&arr[7] = 0000007311bff94c
&arr[8] = 0000007311bff950
&arr[9] = 0000007311bff954

每个元素都是int型（4个字节），数组在内存空间中的地址是连续的，在内存中连续存放

4.二维数组的创建与初始化

// 创建二维数组
int arr[3][4];
char arr[3][5];
double arr[2][4];
 
// 二维数组初始化
int arr[3][4]={1,2,3,4,5}; // 自动换行，剩余元素为0
int arr[3][4]={{1,2,3},{4,5}};
int arr[][] = {1,2,3,4,5}; //不可以这样做，行可以省略，列不可以省略

二维数组行可以省略，列不可以省略，建议都不要省略

5.二维数组的使用

通过下标使用

#include 
#include 
 
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;
}

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

#include 
#include 
 
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]);
      }
   }
   return 0;
}

输出结果

&arr[0][0] = 0000009b30fffa30
&arr[0][1] = 0000009b30fffa34
&arr[0][2] = 0000009b30fffa38
&arr[0][3] = 0000009b30fffa3c
&arr[1][0] = 0000009b30fffa40
&arr[1][1] = 0000009b30fffa44
&arr[1][2] = 0000009b30fffa48
&arr[1][3] = 0000009b30fffa4c
&arr[2][0] = 0000009b30fffa50
&arr[2][1] = 0000009b30fffa54
&arr[2][2] = 0000009b30fffa58
&arr[2][3] = 0000009b30fffa5c

7.数组作为函数参数

7.1 冒泡排序法

10个元素需要9次冒泡排序，n个元素需要n-1次排序

/*
对数组进行升序排序
*/
#include 
#include 
 
void bubble_sort(int arr[], int sz)
{
   // 确定冒泡排序的次数
   int i = 0;
   for (i = 0; i < sz - 1; i++)
   {
      // 一次冒泡排序
      int j = 0;
      for (j = 0; j < sz - 1 - i; j++)
      {
         if (arr[j] > arr[j + 1])
         {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
         }
      }
   }
}
 
int main()
{
   int arr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
   int i = 0;
   int sz = sizeof(arr) / sizeof(arr[0]);
   // 对arr进行排序，升序
   // arr是数组，我们对数组进行传参，实际上传递过去的是数组首元素的地址
   bubble_sort(arr, sz);
   for (i = 0; i < sz; i++)
   {
      printf("%d ", arr[i]);
   }
   return 0;
}

输出结果：1 2 3 4 5 6 7 8 9 

数组名是首元素的地址

sizeof(数组名)   计算的是整个数组的大小，单位是字节

&数组名，数组名代表整个数组，取出的是整个数组的地址