数组介绍

数组指的是一种容器，可以用来存储同种数据类型的多个值

数组的初始化

C语言中的数组必须先定义,然后才能使用数组中保存的数据所谓初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

不初始化

格式：数据类型 数组名[数组长度]; （数组元素值是不确定的，是内存中原有的数据）

例如：int arr[3];

部分初始化

例如：int arr[10] = {1,2,3}; （不完全初始化，剩余的元素默认初始化为0）

全部初始化

格式：数据类型 数组名[数组长度可以省略] = {元素1,元素2,元素3,….};

例如：int arr1[] = {11,22,33};

​ int arr2[3] = {11,22,33};

规定：数组一旦确定下来，长度不会再发生变化

数组元素的访问

格式：数组名[索引或者下标];

索引：索引是数组容器中每个元素的编号，编号从0开始，逐个+1增长

1
2
3
4
5
6
7
8
9
10
int arr[5] = {1,3,5,7,9};
printf(“%d\n”,arr[2]);//输出arr数组2号下标上的数据，也就是5
printf(“%d\n”,arr[5]);//索引5没有这个元素，索引越界结果不可预测
//遍历数组中所有的元素
int n = sizeof(arr)/sizeof(arr[0])
for(int i=0; i < n; i++)
{
    printf("%d\n",arr[i]);
}

sizeof函数

数组长度：sizeof(arr)/sizeof(arr[0]）
最大索引= 数组长度-1

获得整个数组在内存中所占的字节

  • 数组中元素类型一致，所占内存一样
  • 总字节数除以每个元素的字节数

数组元素的修改

在C语言中，数组的大小是固定的，一旦定义后就无法增加或删除元素。因此，没有内置的增加元素和删除元素的操作。

数组名[索引]= 新元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*数组元素逆序*/
#include <stdio.h>
int main() {
    int a[] = {  8, 9, 10,100,23,54,65 };
    int n = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < n; ++i) 
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    // 数组元素逆序
    for (int i = 0; i < n/2; ++i)
    {
        int t = a[i];
        a[i] = a[n - 1 - i];//2 6-1-2
        a[n - i - 1] = t;
    }
    //方法2
    for (int i = 0,k = n-1; i < n/2; i++,k--)
    {
        int t = a[i];
        a[i] = a[k];
        a[k] = t;
    }
    //方法3
    for (int i = 0,k = n-1; i < k; i++,k--)
    {
        int t = a[i];
        a[i] = a[k];
        a[k] = t;
    }

    for (int i = 0; i < n; ++i) 
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

数组元素的排序

规律：
假设：有n个元素
1、需要进行（n-1）轮转换，每轮获取最大值；
2、每轮元素需要与后面的数进行比较，一共需要比较n-1次，但是每轮都获取该轮的最大值，再比较无意义，所以，每轮比较（n-轮数）次；

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 冒泡原版:按升序排序
#include <stdio.h>
int main()
{
    int a[10] = {21, 42, 31, 15, 16, 37, 18, 39, 9, 10};
   
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        { // 内层循环控制每一轮比较的次数
            if (a[j] > a[j + 1])
            { // 如果前一个数比后一个大，则交换
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
        for (int j = 0; j < 10; j++)
        {
            printf("%d ", a[j]);
        }
        printf("\n");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 冒泡优化:按升序排序
#include <stdio.h>
int main()
{
    int a[10] = {21, 42, 31, 15, 16, 37, 18, 39, 9, 10};
   
    for (int i = 0; i < 9; i++)
    {
        int flag = 0;//flag表示是否交换过，如果交换过则flag=1。优化比较总轮数/总趟数
        for (int j = 0; j < 9-i; j++)
        { // 内层循环控制每一轮比较的次数
            if (a[j] > a[j + 1])
            { // 如果前一个数比后一个大，则交换
                flag = 1;
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
            if(flag == 0)
            {//如果成立，说明已经有序，则跳出循环。这一轮没有交换过则说明已经有序，此时flag肯定还是0
            break;//跳出外层循环
        	}
        }
        for (int j = 0; j < 10; j++)
        {
            printf("%d ", a[j]);
        }
        printf("\n");
    }
    return 0;
}

二维数组

二维数组定义

数据类型 数组名 [行数] [列数]；

例如：int arr1[3] [5];

字符数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <string.h>
int main()
{
    char d[] = "xyz123";
    char a[] = {'a','b','c'};//单引号表示字符
    char b[] = {"abcd"};//双引号表示字符串,有\0结束标志
    char c[] = "abcde";
    printf("sizeof(a):%lu\n",sizeof(a));//3
    printf("sizeof(b):%lu\n",sizeof(b));//5
    printf("sizeof(c):%lu\n",sizeof(c));//6

    printf("strlen(b):%lu\n",strlen(b));//4,strlen只计算字符串的长度，实际字符的个数，以\0为结尾标志，不计算\0
    printf("strlen(c):%lu\n",strlen(c));//5,strlen只计算字符串的长度，以\0为结尾标志
    printf("strlen(a):%lu\n",strlen(a));//不一定是3。strlen只计算字符串的长度，以\0为结尾标志
    
    printf("%s,%s,%s\n",a,b,c);//%s用来打印字符串，遇到\0结束
    printf("c[4]:|%c|\n",c[4]);//e
    printf("c[5]：|%c|\n",c[5]);//\0是什么都没有
    printf("|%c|\n",32);

    printf("%lu\n",sizeof("中国人"));//汉字在不同的编码系统下占的字节数是不一样的，gbk是2个字节，utf-8是3个字节
    return 0;
}

注意事项：
使用字符数组定义字符串时，数组的长度应该比字符串的长度多1，以便容纳空字符。

使用指针方式定义字符串时，指针变量指向了字符串常量的首地址，无需指定数组长度。

二维字符数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main(){
    char name[5][20] = {"Tom","Jack","xiaoming","xiaohua","Chinese"};//二维字符数组保存多个字符串
    //二维字符数组，也是一维字符串数组，5个字符串name[0],name[1],....name[4]
    printf("%s,%s\n",name[2],name[4]);
    
    for(int i=0;i<5;i++)
    {
        printf("%s\n",name[i]);
    }

    printf("%c\n",name[0][0]);
    printf("|%c|,|%c|\n",name[0][3],name[0][19]);
    printf("%c\n",name[1][3]);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
void printArr(int arr[],int n)
{
    //打印数组
    for (int i = 0; i < n; ++i) 
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int b[5] = {2,4,6,8,10};
    printArr(a,10);
    printArr(b,5);
    
    char c[10]={0};
    scanf("%s",c);
    printf("%s\n",c);
    return 0;
}