C++数组

C++数组

数组的介绍

数组其实就是一个容器，里面可以存储若干个相同的数据类型的数据。

特性：

• 数组可以存储任意数据类型的数据，但是所有的数据需要是相同的数据类型
• 数组是一个定长容器，一旦初始化完成，长度将不能改变。

数组中的名词：

• 元素：数组中存储的每一个数据
• 长度：数组的容量
• 遍历：依次获取数组中的每一个元素

数组的定义

// 定义指定长度的数组，此时数组中的元素指不确定
int arr1[10];

// 定义数组的同时，设置数组中初始化填充的元素
int arr2[10] = {1,2,3,4,5,6,7,8,9,10};	// 定义了长度为10的数组，其中存储的元素为大括号中的10个数
int arr3[10] = {1,2,3,4,5};				// 定义长度为10的数组，其中存储的元素为1,2,3,4,5，后面的元素都是默认值0

// 定义一个数组，指定初始化值，但不去指定长度，此时数组的长度是由初始化部分元素的数量决定的
int arr4[] = {1,2,3,4,5};	// 定义了一个数组，填充元素是1,2,3,4,5，此时数组的长度是5

数组元素的访问

int arr[10] = {1,2,3,4,5};
cout << arr[0];
cout << arr[1];
~	
cout << arr[9];

// 计算数组长度
int len = sizeof(array) / sizeof(int);

使用下标访问数组，切记不要越界

数组的内存分析

数组是一个容器，在内存中进行空间开辟的时候，并不是一个整体的空间，而是开辟了若干个连续的空间。

例如：int arr[10];

这个数组的长度为10，存储的元素数据类型是 int。也就是说，需要在内存中开辟连续的10个4字节空间来存储元素。

而arr表示的是数组中首元素的内存地址。

当数组作为参数传递到一个函数中的时候，传递的只是首元素的地址。

void printArr(int arr[],int len){
	for(int i=0; i<len; i++){
		cout << arr[i] << ", ";
	}
}
int main(){
	int arr[10]  = {1,2,3,4,5};
	printArr(arr,sizeof(arr) / sizeof(int));
	return 0;
}

数组的遍历

俩种最基本的方法

下标遍历法

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
for(int i=0; i < sizeof(arr) / sizeof(int); i++){
	cout << arr[i] << " ";
}

元素迭代法

// 逻辑：依次将数组中的每一个元素给变量ele进行赋值
// 1，只有在定义数组的代码部分才可以使用，如果将数组通过参数传递到另外一个函数中，此时是不能使用这种方法的
// 2，在迭代的过程中，不能通过ele修改到数组中的元素的指。但是可以通过引用解决这个问题
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
for(int ele : arr){
	cout << ele << " ";
}
// 用解决迭代法不能修改元素值的问题
for(int& ele : arr){
    cout << ele << " ";
    if(ele == 5){
        ele == 500;
    }
}
cout << arr[4];

数组的排序

选择排序

// 选择排序：固定一个下标位，用这一位的元素依次和后面的每一位元素进行比较
void sort01(int arr[], int len) {
    // i的最大值是数组长度减1
	for (int i = 0; i < len - 1; i++)
	{
        // j的初始值等于i+1，最大值是数组长度
		for (int j = i + 1; j < len; j++) {
            // 如果固定的下标位的值，大于比较的元素，则交换
			if (arr[i] > arr[j]) {
				int num = arr[i];
				arr[i] = arr[j];
				arr[j] = num;
			}
		}
	}
}

// 优化之后
// 优化内容：减少数据交换次数，通过内循环找到i位之后最小的元素，然后记录下标，之后与i位进行交换。
void sort02(int arr[], int len) {
	for (int i = 0; i < len - 1; i++) {
        // 定义最小值下标，默认是i
		int index = i;
		for (int j = i + 1; j < len; j++) {
            // 如果最小值下标元素大于比较元素，则将比较元素的下标记录
			if (arr[index] > arr[j]) {
				index = j;
			}
		}
        // 如果最小值下标与i不等于，则交换
		if (index != i) {
			int tmp = arr[i];
			arr[i] = arr[index];
			arr[index] = tmp;
		}
	}
}

// 输出数组函数
void printArr(int arr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}
}

int main1() {
	int arr[10] = { 2,3,4,6,8,1,5,9,10,7 };
	int len = sizeof(arr) / sizeof(int);
    
	// sort01(arr, len);
	sort02(arr, len);
	printArr(arr, len);
	return 0;
}

冒泡排序

void sort03(int arr[],int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

// 输出数组函数
void printArr1(int arr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}
}

int main2() {
	int arr[10] = { 2,3,4,6,8,1,5,9,10,7 };
	int len = sizeof(arr) / sizeof(int);

	sort03(arr, len);
	printArr1(arr, len);
	return 0;
}

数组的查询

顺序查询

// 查找ele在数组中的下标是多少
int indexOf(int arr[], int len, int ele) {
	for (int i = 0; i < len; i++) {
		if (arr[i] == ele) {
			return i;
		}
	}
	return -1;
}

int main3() {
	int arr[] = {2, 3, 4, 6, 8, 1, 5, 9, 10, 7};
	int len = sizeof(arr) / sizeof(int);

	cout << indexOf(arr, len, 7) << endl;
	return 0;
}

二分查询

二分查询，要求数组必须是排序的，否则无法使用二分查询

// 使用二分查找法，从数组中查询元素出现的下标
// 如果数组中不包含这个元素，返回-1
int binaryLookup(int arr[], int len, int ele) {
    // 定义俩个变量，分别用来表示需要查找的范围上限和下限
	int min = 0, max = len - 1;
    
    // 用循环缩小需要查询的范围
    // 循环结束条件：
    // 1、找到这个元素
    // 2、找不到这个元素
	while (min <= max) {
        // 计算中间元素的下标
		int median = (min + max) / 2;
		if (arr[median] < ele) {
            // 说明要查询的元素在右边，下一次查询的时候，缩小范围，修改下限
			min = median + 1;
		}
		else if (arr[median] > ele) {
            // 说明要查询的元素在左边，下一次查询的时候，缩小范围，修改上限
			max = median - 1;
		}
		else {
            // 说明找到了这个元素
			return median;
		}
	}
    // 如果程序执行到这里，说明找不到这个元素
	return -1;
}
int main() {
	int arr[] = { 1,2,3,4,5,6,7,8,9 };
	int len = sizeof(arr) / sizeof(int);
	cout << binaryLookup(arr, len, 9) << endl;
	return 0;
}

顺序查询适合数组元素比较少的情况

二分查询适合数组元素比较多的情况

浅拷贝与深拷贝

• 浅拷贝：也就是地址拷贝，拷贝的是数组的首元素地址，因此对一个数组进行操作都会对另外一个数组产生影响。

  int arr[] = {1,2,3,4};
  // 浅拷贝，将地址拷贝
  int* arr_copy = arr;
  

• 深拷贝：定义一个新的数组，长度与原来的数组相同，将原来数组中的每一个元素依次拷贝到新的数组中。

  int arr[] = {1,2,3,4};
  // 深拷贝，创建一个新的等长数组，并将元素依次拷贝过来
  int arr_copy[4];
  for(int i = 0; i < 4; i++){
  	arr_copy[i] = arr[i];
  }
  

二维数组的定义

int main(){
	// 定义二维数组：
	// 数据类型 标识符[行数][列数];
	int arr1[3][5];
	
	// 数据类型 标识符[行数][列数] = {{v1, v2}, {v1, v2}};
	int arr2[3][5] = {
		{1,2,3,4,5},
		{2,3,4,5,6},
		{3,4,5,6,7}
	};
	
	// 数据类型 标识符[行数][列数] = {v1, v2, v3, v4};
	// 此时系统会将这些元素中，每5个组合到一起
	// 最后剩余不到5个的元素，补0凑够5位拼成一个数组
	int arr3[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	
	// 数据类型 标识符[][列数] = {v1, v2, v3, ···};
	// 此时系统会将这些元素中，每5个组合到一起
	// 最后剩余不到5个的元素，补0凑够5位拼成一个数组
	int arr4[][5] = {1, 2, 3, 4, 5, 2, 2, 3, 4, 5, 1};
}