数组字符串（篇六）

一、数组
1.概念
把具有相同类型的若干变量，按有序的方式组织起来，这些按序排列的同类数据元素
的集合称为数组。

线性存储结构，在内存中按顺序存储

2.一维数组
（1）定义
一维数组同其他变量一样，使用前必须定义

类型说明符 数组名称[size];
类型说明符：int，char， float，double…
数组名称：标识符，驼蜂命名法
数组名时数组唯一标识
size：常量表达式，表示数组元素的个数，也成为数组的长度。size 为 0 的数组没有意义

//定义一个大小为 5 的数组，其中每个数组元素都是 int 类型
int arr[5];
arr:数组名称
5：数组大小即数组元素的个数
int：数组元素的类型

double dArr[5];

（2）数组说明注意
数组的类型实际是数组元素的类型。对于同一个数组来说，其所有元素的数据类型都是相同的
数组名不能与其他变量同名
数组下表是从 0 开始，最大下表为：size - 1
[]:中不能使用变量来表示数组元素的个数

数组在定义时，其大小必须明确！！！

数组元素是按下表依次存储在存储单元中
因此数组占据的内存空间大小 = 数组长度 * 数组元素的类型长度

（3）数组的初始化
//全部初始化
int arr[5] = {1,2,3,4,5};
//部分初始化,其他元素默认为该类型的 0 值
int arr[5] = {1,2,3};
int arr[5] = {[2] = 8, [3] = 9}; //OK,

//省略大小的定义方法
int arr[] = {1,2,3,4}; //OK, 不建议
int arr[]; //Error

//变量初始化 && 数组初始化
int tmp = 0;

int tmp;
tmp = 0;

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

int buf[3];
buf[3] = {1,2,3}; //Error
buf = {1,2,3}; //Error

数组初始化，必须在定义的同时初始化！

int n = 6;
int arr[n]; //Error

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

buf = arr; //Error, 数组名表示地址

（4）数组元素的访问
int buf[5] = {1,2,3,4,5};
buf[0] —> 数组第一个元素
buf[2] —> 数组第三个元素
buf[4] —> 数组第五个元素
buf[5] —> 数组第六个元素 //超出数组超度，越界访问，不可以，未知错误

宏定义数组大小：
#define LEN 5
int arr[LEN] = {1,2,3,4,5};

（5）数组相关地址问题
int arr[5] = {1,2,3,4,5};

区分以下三个地址代表何种意义：
arr:数组名，代表整个数组，同时表示数组首元素的地址
&arr:数组的地址
&arr[0]:数组首元素的地址

//分析以下地址偏移量，来确定每个地址的意义
&arr[0] = 0x7ffe17c68cf0
&arr[1] = 0x7ffe17c68cf4
&arr[2] = 0x7ffe17c68cf8
&arr[3] = 0x7ffe17c68cfc
&arr[4] = 0x7ffe17c68d00

&arr[0] = 0x7ffe17c68cf0
&arr[0]+1 = 0x7ffe17c68cf4
arr = 0x7ffe17c68cf0
arr + 1 = 0x7ffe17c68cf4
&arr = 0x7ffe17c68cf0
&arr + 1 = 0x7ffe17c68d04

（6）数组性质：
数据类型一致
大小固定
数组元素在内存中连续分布

（7）数组大小问题：
类型说明符 数组名称[size];

int arr[5];
数组大小为：
5 * sizeof(arr[0]);
5 * sizeof(int);
sizeof(arr); //整个数组大小

（8）数组元素排序 — 冒泡排序
int arr[5] = {11, 45, 2, 66, 34};

从小到大进行排序，最大值放在最后

第一轮：
arr[0] arr[1] —> arr[1] (45)
arr[1] arr[2] —> arr[2] (45)
arr[2] arr[3] —> arr[3] (66)
arr[3] arr[4] —> arr[4] (66)

	结果: 11, 2, 45, 34, 66

第二轮：
arr[0] arr[1] —> arr[1] (11)
arr[1] arr[2] —> arr[2] (45)
arr[2] arr[3] —> arr[3] (45)

	结果：2, 11, 34, 45, 66

第三轮：
arr[0] arr[1] —> arr[1] (11)
arr[1] arr[2] —> arr[2] (34)

	结果： 2, 11, 34, 45, 66

第四轮：
arr[0] arr[1] —> arr[1] (11)

	结果：2, 11, 34, 45, 66

参加数据个数           比较次数
	   5                      4
	   4                      3
	   3                      2
	   2                      1

因此：
外层循环控制比较的轮数：LEN - 1
内存循环控制比较元素的个数：