C++学习笔记4--数组

概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

一维数组

一维数组的定义方式

一维数组定义的三种方式：

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

    1. 数据类型  数组名[ 数组长度 ];
	int arr[5];
	给数组中的元素进行赋值
	数组元素的下标是从0开始索引的
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;
	访问数据元素
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;
	
	2. 数据类型  数组名[数组长度] = { 值1，值2 ... };
	如果在初始化数据时候，没有全部填写完，会用0来填补剩余数据
	int arr2[5] = { 10,20,30 };
	利用循环 输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}
	3. 数据类型  数组名[ ] = { 值1，值2 ...};
	定义数组的时候，必须有初始长度
	int arr3[] = { 90,80,70,60,50,40,30,20,10 };

一维数组数组名

一维数组名称的用途:

1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址

	数组名用途
	1、可以通过数组名统计整个数组占用内存大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "整个数组占用内存空间为： " << sizeof(arr) << endl<< endl;
	cout << "每个元素占用内存空间为： " << sizeof(arr[0]) << endl<< endl;
	cout << "数组中元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl<< endl;

	2、可以通过数组名查看数组首地址
	cout << "数组首地址为： " << (int)arr << endl<< endl;
	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl<< endl;
	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl<< endl;

	数组名是常量，不可以进行赋值操作
	arr = 100;

元素逆置

//实现数组元素逆置

	//1、创建数组
	int arr[5] = { 1,3,2,5,4 };
	cout << "数组逆置前：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}

	//2、实现逆置
	//2.1记录起始下标位置
	//2.2记录结束下标位置
	//2.3起始下标与结束下标的元素互换
	//2.4起始位置++  结束位置--
	//2.5循环执行2.1操作，直到起始位置 >= 结束位置
	int start = 0; //起始下标
	int end = sizeof(arr) / sizeof(arr[0]) - 1; //结束下标

	while (start < end)
	{
		//实现元素互换
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;

		//下标更新
		start++;
		end--;
	}

	//3、打印逆置后的数组
	cout << "数组元素逆置后：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}

冒泡排序

作用：最常用的排序算法，对数组内元素进行排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3. 复以上的步骤，每次比较次数 -1,直到不需要比较
4. 排序总轮数 = 元素个数 - 1
5. 每轮对比次数 = 元素个数 - 排序轮数 - 1

#include<iostream>
using namespace std;

int main() {

	//利用冒泡排序实现升序序列
	int arr[9] = { 4,2,8,0,5,7,1,3,9 };

	cout << "排序前：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	//开始冒泡排序
	// 总共排序轮数为 元素个数 - 1
	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] << " ";
	}
	cout << endl;

	system("pause");

	return 0;
}

二维数组

二维数组的定义方式

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

第二种比较直观。

	//1. 数据类型  数组名[ 行数 ][ 列数 ];
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;
	外层循环打印行数，内层循环打印列数
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << endl;
		}
	}
	
	//2. 数据类型  数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };

	int arr2[2][3] = 
	{
		{1,2,3},
		{4,5,6}
	};
	
	//3. 数据类型  数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	int arr3[2][3] = { 1,2,3,4,5,6 };

	//4. 数据类型  数组名[  ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	int arr4[][3] = { 1,2,3,4,5,6 };

二维数组数组名

二维数组名称用途

	1、可以查看占用内存空间大小
	int arr[2][3] = 
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "二维数组占用内存空间为： " << sizeof(arr) << endl;
	cout << "二维数组第一行占用内存为： " << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存为： " << sizeof(arr[0][0]) << endl;

	cout << "二维数组行数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组列数为： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

	2、可以查看二维数组的首地址
	cout << "二维数组首地址为： "<< (int)arr << endl;
	cout << "二维数组第一行首地址为： " << (int)arr[0] << endl;
	cout << "二维数组第二行首地址为： " << (int)arr[1] << endl;

	cout << "二维数组第一个元素首地址： " << (int)&arr[0][0] << endl;
	cout << "二维数组第二个元素首地址： " << (int)&arr[0][1] << endl;