数组

基础用法

/*
	元素类型 数组名称[元素个数];
	元素类型：就是数组中需要存储的数据类型，一旦指定，数组中就只能存储该类型的数据
	元素个数：就是数组中能够存储的数据（元素）个数
 */   
// 定义一个名称叫做scores可以存储3个整数类型的数组
int scores[3];

// 初始化，给数组赋值
scores[0] = 10;
scores[1] = 60;
scores[2] = 90;   

 // 从数组中取值
printf("scores[0] --> %i\n", scores[0]);        // scores[0] --> 10

定义和初始化

// 先定义，后初始化
int scores[3];
scores[0] = 10;
scores[1] = 60;
scores[2] = 90;

// 定义的同时初始化
int scores[3] = {60, 70, 90};

// 定义的同时初始化数组可以省略元素的个数，初始化的数据个数就是数组的长度
int scores[] = {60, 70, 90};

int scores[]; 		// 这样会报错，定义不初始化必须指定元素个数

// 给指定索引赋值，定义时初始化
int scores[101] = {[99] = 3, [100] = 1};

// 给指定索引赋值，先定义，后初始化
int scores[101];
scores[99] = 3;
scores[100] = 1;

// 不可以先定义，后初始化多个元素，后初始化只可以单个赋值
int scores[2];
scores = {1, 2};	// 这样是错误写法

• 完全初始化

int scores[3] = {60, 70, 90};

• 部分初始化

// 在部分初始化中，没有被初始化的元素默认是0
int scores[5] = {60, 70, 90};

注意：

• 如果没有对数组进行初始化操作，不要使用数组中的数据，可能是一段垃圾数据（随机值）
• 定义数组的时候，数组的元素个数不能使用变量，如果使用变量，那么数组中的是一些随机数
• 使用变量定义了数组的元素个数，
  • 不初始化，数组中元素对应的值是随机值
  • 初始化则会直接报错

数组遍历

取出数组中所有的值，称之为遍历

int main(int argc, const char * argv[]) {
    
    /*
     数组的定义格式：
        元素类型 数组名称[元素个数];
        元素类型：就是数组中需要存储的数据类型，一旦指定，数组中就只能存储该类型的数据
        元素个数：就是数组中能够存储的数据（元素）个数
     */

    int scores[10] = {60, 70, 90, 45, 56, 78, 45, 21, 58, 56};
    
    // 计算数组的长度，用数组的总长度 / 单个元素的长度
    int arrLenght = sizeof(scores) / sizeof(scores[0]);

    for (int i = 0; i < arrLenght; i++) {
        printf("scores[%i] --> %i\n", i, scores[i]);
    }
    return 0;
}

数组在内存中存储细节

#include <stdio.h>

int main(int argc, const char * argv[]) {

    int scores[4] = {60, 70, 90, 45};
    printf("scores[0] --> %p\n", &scores[0]);   // scores[0] --> 0x7ffeefbff520
    printf("scores[1] --> %p\n", &scores[1]);   // scores[1] --> 0x7ffeefbff524
    printf("scores[2] --> %p\n", &scores[2]);   // scores[2] --> 0x7ffeefbff528
    printf("scores[3] --> %p\n", &scores[3]);   // scores[3] --> 0x7ffeefbff52c
    printf("scores[4] --> %p\n", &scores[4]);   // scores[4] --> 0x7ffeefbff530
    
    return 0;
}

二维数组

数组中的每一个元素又是一个数组，那么这个数组就称之为二维数组
元素类型 数组名称[一维数组的个数][每个一维数组的元素个数];
元素类型：说明二维数组中每个一维数组存储什么类型的数据
一维数组的个数：说明二维数组有多少个元素
每个一维数组的元素个数：说明二维数组中每一个一维数组的元素个数

遍历二维数组

#include <stdio.h>

int main(int argc, const char * argv[]) {
    
    int scoress[3][5] = {
        {1, 3, 5, 7, 9},
        {2, 4, 6, 7, 9},
        {1, 3, 9, 7, 9},
    };

    // 遍历二维数组
    // 1.计算二维数组中有几个一维数组
    int length = sizeof(scoress) / sizeof(scoress[0]);
    
    // 2.循环二维数组
    for (int i = 0; i < length; i++) {
        
        // 3.计算一维数组中有几个元素
        int length = sizeof(scoress[i]) / sizeof(scoress[i][0]);
        
        // 4.循环输出一维数组的数据
        for (int j = 0; j < length; j++) {
            printf("scoress[%i][%i] --> %i\n", i, j, scoress[i][j]);
        }
        printf("\n");
    }
    return 0;
}

例子

计算数组的最大值

#include <stdio.h>
void printArray(int nums[]);
int arrayMax(int values[], int lenght);
int arrayMax2(int values[], int lenght);


// 计算数组中的最大值
int main(int argc, const char * argv[]) {
    
    int nums[5] = {15, 42, 35, 74, 55};
    
    int lenght = sizeof(nums) / sizeof(nums[0]);
    
    int maxNum = arrayMax(nums, lenght);
    printf("maxNum -->%i\n", maxNum);
    
    int maxNum2 = arrayMax2(nums, lenght);
    printf("maxNum2 -->%i\n", maxNum2);
    return 0;
}


// 第一种方法
int arrayMax(int values[], int lenght) {
    
    // 1.定义变量，保存数组中第一个值
    int max = values[0];
    
    // 2.循环数组，从数组的第二个元素开始循环，因为第一个元素已经赋值给max了，不需要自己和自己比较
    for (int i = 1; i < lenght; i++) {
        
        // 3.取出数组中对应的值与max进行对比
        if (max < values[i]) {
            // 如果max小于数组获取当前索引的值，则将max改为当前数组元素的值
            max = values[i];
        }
    }
    
    // 4.返回数组中找到的最大值
    return max;
}

// 第二种方法
int arrayMax2(int values[], int lenght) {
    
    // 1.定义变量，保存索引
    int max = 0;
    
    // 2.循环数组，从数组的索引1开始，因为max已经保存了第0个索引
    for (int i = 1; i < lenght; i++) {
        
        // 3.取出数组中对应的值与max进行对比
        if (values[max] < values[i]) {
            // 如果values[max]小于数组获取当前索引的值，则将max改为当前数组元素的索引
            max = i;
        }
    }
    
    // 4.返回数组中找到的最大值
    return values[max];
}