数组

1.概述
2.一维数组
3.二维数组

概述

数组 就是一个集合里面存放了相同类型的数据元素
特点：
1.每个数据元素都是相同的数据类型
2.数组是由连续的内存位置组成的

一维数组

定义方法

1.数组类型 数组名[数组长度];
2.数据类型 数组名[数组长度] = (值1,值2...);
3.数据类型 数组名[ ] = {值1，值2...};

数组的下标

数组的下表是从0开始的 范围是0~n-1（n为元素的数量）
==数组中的元素下标是从零开始索引的==
在数组中可以通过元素的下标访问元素
调用数组中元素：数组名[下标/索引]
例如 在数组 int arr[3] = {10,20,30};中：

元素	10	20	30
下标	0	1	2
访问元素的方式	arr[0]	arr[1]	arr[2]

代码示例：

#include <iostream>  
using namespace std;  
int main(){  
    //数组类型 数组名[数组长度]  
    int arr1[3];  
    //给数组中的元素进行赋值  
    arr1[0] = 10;  
    arr1[1] = 20;  
    arr1[2] = 30;  
    //输出元素中的值  
    cout << arr1[0] << endl;  
    cout << arr1[1] << endl;  
    cout << arr1[2] << endl;  
    cout << "--- 我是分割线 ---" << endl;  
    //数据类型 数组名[数组长度] = (值1,值2...);  
    //如果在初始化时没有全部填写完 那么会用0来填补剩余的数据  
    int arr2[] = {10,20,30,40,50};  
    cout << arr2[0] << endl;  
    cout << arr2[1] << endl;  
    cout << arr2[2] << endl;  
    cout << arr2[3] << endl;  
    cout << arr2[4] << endl;  
        cout << "--- 我是分割线 ---" << endl;  
  
    //利用循环 输出数组中的元素  
    for(int i = 0; i < 5;i++){  
        cout << arr2[i] << endl;  
    }  
    cout << "--- 我是分割线 ---" << endl;  
    //数据类型 数组名[ ] = {值1，值2...};  
    //定义数组时 必须有初始长度  
    int arr3[] = {50,40,30,20,10};  
    //利用循环 输出数组中的元素  
    for(int i = 0; i < 5;i++){  
        cout << arr3[i] << endl;  
    }  
        return 0;  
}

输出结果：

10
20
30
--- 我是分割线 ---
10
20
30
40
50
--- 我是分割线 ---
10
20
30
40
50
--- 我是分割线 ---
50
40
30
20
10

数组名称的用途

1.可以统计整个数组内存中的长度 sizeof(arr)
2.可以获取数组在内存中的首内存地址
代码示例：

#include <iostream>
using namespace std;
int main(){
    int arr[10] = {10,20,30,40,50,60,70,80,90,100};
    //1.可以通过数组名统计整个数组占用的内存大小
    //输出结果为40  数组中的元素均为int 
    //一个int占4字节 一共十个 所以是40
    cout << "整个数组占用的内存空间为：" << sizeof(arr) << endl;
    //每个元素占用的内存空间
    cout << "每个元素占用的内存空间为：" << sizeof(arr[0]) << endl;
    //数组中元素个数：数组占用的内存空间/每个元素占用的内存空间
    cout << "数组中元素个数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
    //2.可以通过数组名查看首地址 
    //输出的地址为16进制 
    cout << "数组的首地址为：" << arr << endl;
    //数组中元素的地址 &为寻址的符号
    cout << "数组中第一个元素的地址为：" << &arr[0] << endl;
    cout << "数组中第二个元素的地址为：" << &arr[1] << endl;
    //数组名是一个常量 不可以进行赋值操作
    return 0;
}

整个数组占用的内存空间为：40
每个元素占用的内存空间为：4
数组中元素个数为：10
数组的首地址为：0x547abff760
数组中第一个元素的地址为：0x547abff760
数组中第二个元素的地址为：0x547abff764

冒泡排序

1.比较相邻的两个元素 如果第一个比第二个大就交换位置
2.对每一对相邻元素做同样的工作 执行完毕后 找到第一个最大值
3.重复以上步骤 每次比较次数-1 直到不需要比较

示例

第一轮排序

1.比较第一个和第二个元素 4 > 2 交换位置 指针右移

2.比较二三两个元素 4 < 8 不交换 指针向右移

3.比较三四两个元素 8 > 0 交换位置 并且指右移

4.比较四五两个元素 8 > 5交换位置 并且指右移

5.比较四五两个元素 8 > 7 交换位置 并且指右移

6.比较五六两个元素 8 > 1 交换位置 并且指右移

7.比较六七两个元素 8 > 3 交换位置 并且指右移

8..比较八九两个元素 8 < 9 交换位置 并且指右移

第二，第三，...，第n轮同理
代码示例：

#include<iostream>
using namespace std;
int main() {
    int arr[9] = {4,2,8,0,5,7,1,3,6};
    cout << "排序前：" << endl;
    for(int i = 0; i < 9; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
    //开始冒泡排序
    //排序总轮数 为元素个数减一
    for(int i = 0; i < 9 - 1; i++){
        //内层循环对比 对比次数 = 元素个数 - 当前的轮数 - 1
        for(int j = 0; j < 9 - i - 1; j++){
            //如果第一个数字比第二个 则交换这两个数字
            if(arr[j] > arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j +1];
                arr[j + 1] = temp;
            }
        }
    }
    //排序后结果
    cout << "排序后：" << endl;
    for(int i = 0; i < 9; i++){
        cout << arr[i] << " ";
    }
}

输出结果：

排序前：
4 2 8 0 5 7 1 3 6
排序后：
0 1 2 3 4 5 6 7 8

二维数组

二维数组是在一维数组的基础上多加了一个维度

二维数组定义方式

1.数据类型 数组名[行数][列数];
2.数据类型 数组名[行数][列数] = {{数据1,数据2} , {数据3,数据4}};
3.数据类型 数据名[行数][列数] = {数据1，数据2，数据3,数据4};
4.数据类型 数据名[][列数] = {数据1，数据2，数据3,数据4};

以上4种定义方式 利用第二种更加直观 提高代码可读性

(0,0)	(0,1)	(0,2)
(1,0)	(1,1)	(2,2)

代码示例：

#include<iostream>  
  
using namespace std;  
int main() {  
    //二维数组定义方式  
            //1.数据类型 数组名[行数][列数];  
    int arr1[2][3];  
    arr1[0][0] = 1;  
    arr1[0][1] = 2;  
    arr1[0][2] = 3;  
    arr1[1][0] = 4;  
    arr1[1][1] = 5;  
    arr1[1][2] = 6;  
        //外层循环打印行数 内层循环打印列数  
    for(int i = 0; i < 2; i++){  
        for(int j = 0; j < 3; j++){  
            cout << arr1[i][j] << " ";  
        }  
        cout << endl;  
    }  
        //2.数据类型 数组名[行数][列数] = {{数据1,数据2} , {数据3,数据4}};  
    int arr2[2][3] = {  
        {11,22,33},  
        {44,55,66}  
    };  
    for(int i = 0; i < 2; i++){  
        for(int j = 0; j < 3; j++){  
            cout << arr2[i][j] << " ";  
        }  
        cout << endl;  
    }  
        //3.数据类型 数据名[行数][列数] = {数据1，数据2，数据3,数据4};  
    int arr3[2][3] = {  
        111,222,333,444,555,666  
    };  
    for(int i = 0; i < 2; i++){  
        for(int j = 0; j < 3; j++){  
            cout << arr3[i][j] << " ";  
        }  
        cout << endl;  
    }  
        //4.数据类型 数据名[][列数] = {数据1，数据2，数据3,数据4};  
    int arr4[][3] = {  
        1,2,3,4,5,6  
    };  
    for(int i = 0; i < 2; i++){  
        for(int j = 0; j < 3; j++){  
            cout << arr4[i][j] << " ";  
        }  
        cout << endl;  
    }  
    return 0;  
}

输出结果：

1 2 3
4 5 6
11 22 33
44 55 66
111 222 333
444 555 666
1 2 3
4 5 6

二维数组的数组名称

查看二维数组所占内存空间
获取二维数组首地址

代码示例：

#include<iostream>
using namespace std;
int main(){
    //二维数组的名称用途
    
    //1、可以查看内存空间大小
    double arr[2][3] = {
        {1,2,3},
        {4,5,6}
    };
    cout << "二维数组所占内存空间大小:" << sizeof(arr) << endl;
    cout << "二维数组第一行所占内存空间大小:" << sizeof(arr[0]) << endl;
    cout << "二维数组第一个元素所占内存空间大小:" << sizeof(arr[0]) << endl;
    cout << "二维数组行数为" << sizeof(arr) / sizeof(arr[0]) << endl;
    cout << "二维数组行数为" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
    //2、可以查看二维数组的首地址
    cout << "二维数组的首地址为："  << arr << endl;
    cout << "二维数组的第一行首地址为："  << arr[0] << endl;
    cout << "二维数组的第二行首地址为："  << arr[1] << endl;
    //访问元素首地址需要加取址符&
    cout << "二维数组的第一个元素的首地址为："  << &arr[0][0] << endl;
    return 0;
}

输出结果：

二维数组所占内存空间大小:48
二维数组第一行所占内存空间大小:24
二维数组第一个元素所占内存空间大小:24
二维数组行数为2
二维数组行数为3
二维数组的首地址为：0xd2ff3ff690
二维数组的第一行首地址为：0xd2ff3ff690
二维数组的第二行首地址为：0xd2ff3ff6a8
二维数组的第一个元素的首地址为：0xd2ff3ff690