初级C语言 数组

数组

1. 一维数组
2. 二维数组

数组是一组相同类型元素的集合。

1.1> 一维数组的创建与初始化

创建
元素类型 数组名 [常量表达式 ]
int arr[]

初始化
数组创建时，给予数组一些数值。
int arr[5]={1,2,3,4,5}
int arr[5]={1,2,3} 未完全初始化，其余的元素默认为0

1.2> 字符串长度的计算

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "Crush";
	printf("%d\n", sizeof(arr));
	printf("%d\n", strlen(arr));
	return 0;
}

“Crush"在字符数组中存放的形式为 C r u s h \0
一共六个字符
sizeof计算数组arr所占空间的大小 ,单位字节
库函数strlen计算’\0’之前的字符个数

#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "Crush";
	char arr2[] = { 'C','r','u','s','h' };
	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	return 0;
}

char arr1[] C r u s h \0
char arr2[] C r u s h
34为随机值，库函数strlen只有遇到\0时才会停止计算。

1.3> 一维数组的使用
1.数组是通过下标使用的，下标从零开始。
2.sizeof可计算数组的大小,sizeof(arr)/sizeof(arr[0])计算元素个数。

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	printf("sz = %d\n", sz);
	return 0;
}

1.4>一维数组在内存中的存储

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("&arr[%d]=%p\n",i, &arr[i]);
	}
	return 0;
}

从表中可以发现，数组中的元素是按顺序存储的（一个数字占四个字节，故相邻数字的存储相差四个字节），并且由低地址向高地址存储。

2.1> 二维数组的创建和初始化
创建
实质上与一维数组相似
int arr [3][4] 可以理解为数学中的平面直角系中 x=4,y=3。三行四列
其中x不可省略。

初始化
int arr [3][4]={1，2，3，4，5}
储存形式如下

1 2 3 4
5 0 0 0
0 0 0 0

int arr[3][4]={{1，2，3}，{4，5}}

1 2 3 0
4 5 0 0
0 0 0 0

2.2> 二维数组的使用与一维数组类似

#include<stdio.h>
int main()
{
	int arr[3][4] = { {1,2,3},{4,5,6} };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

2.3> 二维数组在内存中的存储也是连续的，且由低到高。

#include<stdio.h>
int main()
{
	int arr[3][4] = { {1,2,3},{4,5,6} };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d] = %p\n ", i, j,&arr[i][j]);
		}
	}
	return 0;
}

换个角度思考，我们可以认为二维数组是由Y个一维数组组成，其中一维数组元素个数为X

数组作为函数参数

冒泡排序
将数字由小到大排序

#include<stdio.h>
void Bubble(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)//排序的次数
	{
		int j = 0;
		int order = 1;//假设需排序的数字已有序
		for (j = 0; j < sz - 1 - i; j++)//开始排序
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				order = 0;//说明本次排序的数字并不完全有序
			}
		}
		if (order == 1)
		{
			break;
		}
	}
}
int main()
{
	int arr[] = {9,8,7,6,5,4,3,2,1,0};
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble(arr,sz);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

数组名的本质是首元素的地址

#include<stdio.h>
int main()
{
	int arr[] = { 0,1,2,3,4,5,6 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

存在两个例外
a. sizeof（数组名） 计算的是整个数组的大小（字节）
b. &数组名 表示整个数组的地址

由上图可知，&arr表示为整个数组的地址。