C++之利用数组处理批量数据（一）

1.数组

数组（array）是有序数据的集合，用一个统一的名字代表一批数据，用序号或下标来区分各个数据。数组名和下标唯一地标识一个数组中的一个元素。同一数组中的每一个元素都必须属于同一数据类型。一个数组在内存中占一片连续的存储单元。

2.定义和引用一维数组

2.1 定义一维数组

定义一维数组的一般形式为：类型名 数组名[常量表达式]；例如：

int a[10];
int a[2 * 5];
int a[n * 2];//已定义 n 为常变量

常量表达式中可以包括常量、常变量和符号常量，但不能包含变量。即不允许对数组的大小作动态定义。

int n;
cin >> n; 	//输入 a 数组长度
int a[n];	//试图根据 n 的值决定数组的长度，错误
const int n = 5;	// n 为常变量，数组定义合法

2.2 一维数组的初始化

对数组元素的初始化可以用以下方法实现。

1. 在定义数组时对全部数组元素赋予初值

int a[10] = {0,1,2,3,4,5,6,7,8,9};

2. 可以只给一部分元素赋值

int a[10] = {0,1,2,3,4};

定义 a 数组有10个元素，但花括号内只提供5个初值，表示只给前面5个元素赋初值，后5个元素值默认为0。

3. 在对全部数组元素赋初值时，可以不指定数组长度

int a[] = {1,2,3,4,5}

花括号中有5个数，系统会据此自动定义 a 数组的长度为5。
下面给出两个使用一维数组的例子。

//例 用数组问题来处理求Fibonacci问题
int main(){
	int i;
	int f[20] = { 1, 1 }; //f[0]=1,f[1]=1
	for (i = 2; i < 20; i++)
		f[i] = f[i - 1] + f[i - 2];
	for (i = 0; i < 20; i++)  //输出20个数时，每5个数一行
	{
		if (i % 5 == 0)cout << endl;
		cout << setw(8) << f[i];
	}
	cout << endl;
	return 0;
}

//例 编写程序，用起泡法对10个数排序（由小到大) 设定a[11]  a[0]不用，只用a[1]~a[10]
int main(){
	int a[11];
	int i, j, t;
	cout << "input 10 numbers:" << endl;
	for (i = 1; i < 11; i++)
		cin >> a[i];
	cout << endl;
	for (j = 1; j <= 9;j++)
	for (i = 1; i <= 10 - j;i++)
	if (a[i]>a[i + 1])
	{
		t = a[i]; a[i] = a[i + 1]; a[i + 1] = t;
	}
	cout << "the sorted numbers:" << endl;
	for (i = 1; i < 11; i++)
		cout << a[i] << ",";
	cout << endl;
	return 0;
}

3.定义和引用二维数组

3.1 定义二维数组

定义二维数组的一般形式为：类型名 数组名[常量表达式] [常量表达式]；例如：float a[3][4], b[4][5];可以把二维数组看作一种特殊的一维数组：它的元素又是一个一维数组。例如，可以把 a 看作一个一维数组，它有3个元素：a[0],a[1],a[2]，每个元素又是一个包含4个元素的一维数组。a[0],a[1],a[2]是3个一维数组的名字。
上面定义的二维数组可以理解为定义了3个一维数组，相当于

float a[0][4],a[1][4],a[2][4]

此处把a[0],a[1],a[2]作一维数组名，这3个一维数组各有4个元素。
C++中，二维数组中元素排列的顺序是：按行存放，即在内存中先顺序存放第一行的元素，再存放第二行的元素。

3.2 二维数组的初始化

对数组元素的初始化可以用以下方法实现。

1. 按行给二维数组全部元素赋初值。

int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

2. 可以将所有数据写在一个花括号内，按数组排列的顺序对全部元素赋初值。

int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

3. 可以对部分元素赋初值。

int a[3][4] = {{1},{5},{9}};

它的作用是只对各行第一列的元素赋初值，其余元素值自动置为0。
4. 如果对全部元素都赋初值（即提供全部初始数据），则定义数组时对第1维的长度可以不指定，但第二维的长度不能省。

int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

下面给出两个使用二维数组的例子。

//例 将一个2*3的二维数组行列元素互换，存到3*2的数组中
int main(){
	int a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
	int b[3][2], i, j;
	cout << "array a:" << endl;
	for (i = 0; i < 2; i++){
		for (j = 0; j < 3; j++)
		{
			cout << a[i][j] << " ";
			b[j][i] = a[i][j];
		}
		cout << endl;
	}
	cout << "array b；" << endl;
	for (i = 0; i < 3; i++){
		for (j = 0; j < 2; j++)
			cout << b[i][j] << " ";
		cout << endl;
	}
	return 0;
}

//例 有一个3*4矩阵，求出其中值最大的那个元素，并输出行号和列号
int main(){
	int i, j, row = 0, colum = 0, max;
	int a[3][4] = { { 5, 12, 23, 56 }, { 19, 28, 37, 46 }, { -12, -34, 6, 8 } };
	max = a[0][0];
	for (i = 0; i < 3;i++)
	for (j = 0; j < 4;j++)
	if (a[i][j]>max)
	{
		max = a[i][j];
		row = i;
		colum = j;
	}
	cout << "max=" << max << endl;
	cout << "row=" << row << endl;
	cout << "colum=" << colum << endl;
	return 0;
}

4.用数组作函数参数

变量和常量可以用作函数实参，同样数组元素也可以作函数实参，其用法与变量相同。数组名也可以作实参和形参，传递的是数组的起始地址。

1. 用数组元素作函数实参
   数组元素作为函数的实参，与用变量作实参一样，将数组元素的值传送给形参变量。

//例 有一个3*4矩阵，求出其中值最大的那个元素，并输出行号和列号。用函数处理，用数组元素作函数实参
int main(){
	int max_value(int x, int max); //函数声明
	int i, j, row = 0, colum = 0, max;
	int a[3][4] = { { 5, 12, 23, 56 }, { 19, 28, 37, 46 }, { -12, -34, 6, 8 } };  //数组初始化
	max = a[0][0];
	for (i = 0; i < 3; i++)
	for (j = 0; j < 4; j++)
	{   
		max = max_value(a[i][j], max);  //调用函数
		if (max==a[i][j]){ //好吧，此处刚刚写了=，结果就出错了。要用==
			row = i;
			colum = j;
		}	
	}
	cout << "max=" << max << endl;
	cout << "row=" << row << endl;
	cout << "colum=" << colum << endl;
	return 0;
}

int max_value(int x, int max){
	if (x > max) return x;
	else return max;
}

2. 用数组名作函数参数
   可以用数组名作函数参数，此时实参和形参都用数组名或指针变量。数组名代表数组首元素的地址。因此用数组名作函数实参时，只是将实参数组首元素的地址传递给形参。形参可以是数组名，也可以是指针变量，它们用来接收实参传来的地址。如果形参是数组名，它代表的是形参数组首元素的地址。在调用函数时，将实参数组首元素的地址传递给形参数组名。这样实参数组和形参数组就共占同一段内存单元。
   用数组名作函数实参时，如果改变了形参数组元素的值将同时改变实参数组元素的值。

//例 用选择法对数组中的10个数按由小到大排序
int main(){
	void select_sort(int array[], int n); //函数声明
	int a[10], i;
	cout << "enter the original array:" << endl;
	for (i = 0; i < 10; i++)
		cin >> a[i];
	cout << endl;
	select_sort(a, 10); //函数调用，数组名作实参
	cout << "the sorted array:" << endl;
	for (i = 0; i < 10; i++)   //输出10个已排好序的数
		cout << a[i] << " ";
	cout << endl;
	return 0;
}

void select_sort(int array[], int n){      //形参array是数组名
	int i, j, k, t;
	for (i = 0; i < n - 1; i++){
		k = i;
		for (j = i + 1; j < n;j++)
		if (array[j] < array[k])k = j;
		t = array[k]; array[k] = array[i]; array[i] = t;
	}
}

实际上，声明形参数组并不意味着真正建立一个包含若干个元素的数组，在调用函数时也不对它分配存储单元，只是用 array[ ] 这样的形式表示 array 是一维数组的名字，用来接收实参传来的地址。因此array[ ] 中方括号内的数值并无实际作用，编译系统对一维数组方括号内的内容不予处理。形参一维数组的声明中可以写元素个数，也可以不写。C++实际上只把形参数组名作为一个指针变量来处理，用来接收从实参传过来的地址。