【C语言】数组

一维数组

什么是数组？
数组是一组相同类型元素的集合。数组基本结构是
数据类型 数组名 [常量表达式]
根据【】有多少分为一维数组，二维数组，三维数组，多维数组。

一维数组的创建和初始化

建立一个数组是十分容易的，

int arr[];
char ch[];

这就建立了一个整型的和一个字符的数组，
数组的建立要求【】里必须是常量表达式。

int n=8;
int arr[n];

像这样的建立是错误的，这种语法只有C99支持在C99语法中，这种情况被称为变长数组，数组的大小是一个变量。
初始化就是在创建时赋值，我们需要用到大括号{}或者双引号" ".

int arr[2]={1,2};

这就是一个包含元素1和2的数组，这种叫做完全初始化，

int arr[6]={1,2,3};

这种情况叫做不完全初始化，此时后面空着的部分都默认为0.

当我们创建一个字符数组时，初始化一个字符串，这个字符串后带着一个\0，表示结束，如果一个字符一个字符的话，就没有这个符号，需要我们手动加上，这两种的数组对我们使用也有影响。

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

int main()
{
	char ch1[] = "hehe";
	char ch2[] = {'h', 'e', 'h', 'e'};


	printf("%s\n", ch1);
	printf("%s\n", ch2);


	return 0;
}

这个程序运行后，结果是这样的

字符而非字符串的后面有一串乱码，这就是影响，当我们计算长度时，\0不计入字符串长度，所以第一个长度应该是4，而下面的这个因为没有终止符号，我们不知道他的后面还有多少位，所以他的长度是一个随机值。

一维数组的使用

如果我们要用到100个数，我们可以int a,int b一直到100个，但这样太麻烦而且不美观，这时候我们就可以建立一个数组，既然创建了这么多变量，我们肯定是要使用他的，如何使用呢？
我们需要用到下标引用操作符，就是前面说的中括号【】，我们需要使用这个下标引用符去访问数组。

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

printf("%d",arr[2]);

这表示我们要将上面创建的数组中下标为2的数打印出来，最终打印出来的是二，我们要知道，下标是从0开始的。
下标的大小可以通过sizeof()计算，

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

int main()
{
	char ch1[] = "hehe";
	char ch2[] = {'h', 'e', 'h', 'e'};

	int a = sizeof(ch1) / sizeof(ch1[0]);
	int b = sizeof(ch2) / sizeof(ch2[0]);

	/*printf("%s\n", ch1);
	printf("%s\n", ch2);*/

	printf("%d\n",a);
	printf("%d\n", b);

	return 0;
}

虽然\0不算字符串的长度，但是也算作数组里的一个元素，所以上面是5，下面是4.

一维数组的存储

我们要知道，对于数组来说，第一个元素的地址就是数组的地址，要知道数组的存储，我们要知道他的地址

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };
	int i = 0;

	for (i = 0; i < 10; i++)
		printf("&arr[i]= %p\n", &arr[i]);


	return 0;
}

十个地址就出来了，这是16进制，我们通过观察地址发现，每个地址间相差4个字节，这说明数组之间的元素地址是连续的，这样我们只要知道其中一个就可以知道其他任意元素了。随着下标增长，地址是由高到低变化的。

二维数组

二维数组的创建和初始化

二维数组就是有两个中括号，他的创建和一维数组一样

int arr[3][4];

这就是一个二维数组，他的初始化也是一样的

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

这里的3和4可以说是3行4列，在编译器运行时，他可以根据我们的元素来判断有多少行，但是无法判断列，所以在二维数组的写法中，第一个也就是行可以省略，列不能。

此时的数组是这样看的，类比于我们学的直角坐标系，若要对一行中的数进行初始化，我们还要再用一个{}

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

这样我们就可以对某一行赋值了。

二维数组的使用

二维数组的使用还是那样，使用下标引用符，不过要像找坐标一样找到他的下标
比如第二行第三个数
对应的是arr[1][2]

二维数组的存储

还是来看一下他的地址

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

int main()
{
	int arr[3] [4]= { 0 };
	int i = 0;

	for (i = 0; i < 3; i++)
	{
       int j=0;
	   for(j-0;j<4;j++)
	    printf("&arr[i][j]= %p\n", &arr[i][j]);
	}
	return 0;
}

我们可以发现，每个地址之间相差仍然是4，不管是同一行的还是跨行的，这说明二维数组其实排列起来也像一维数组一样,都是连续的。

我们把他们一一列举出来
arr[0][0] arr[0][1] arr[0][2] arr[0][3]
arr[1][0] arr[1][1] arr[1][2] arr[1][3]
arr[2][0 ]arr[2][1] arr[2][2] arr[2][3]
这类似与有三个一维数组，数组名分别是arr[0],arr[1]和arr[2]。

数组作为函数参数

这个我们来举个例子
创建一个数组，有10个元素，是0~9，起初是倒序，要求我们把他变成正序。
数字本来是 9 8 7 6 5 4 3 2 1 0，我们要把他变成0 1 2 3 4 5 6 7 8 9
这里我们要使用冒泡排序。
什么是冒泡排序呢？
就是两两相邻的数作比较，还有可能交换位置。

数字就会这样变化，变成8765432109，然后就是前面的9个数字再次重复这个过程，最终变更成0123456789，

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

void sort(int arr[],int a)
{
	int i = 0;

	for (i = 0; i < a - 1;/*10个元素要有9次排序，元素数量减1*/i++)
	{
		//一次排序的过程
		int j = 0;
		for (j = 0; j < a - 1 - i;/*每次排序数量减1，还要再减去已经排过序的次数*/j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int b = arr[j];//前后两个数交换
				arr[j] =arr[j + 1] ;
				arr[j + 1] = b;
			}
		}
	}
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };//创建数组
	//计算数组大小
	int a = sizeof(arr) / sizeof(arr[0]);
	sort(arr,a);//冒泡排序的函数
	return 0;
}

这样就可实现了。


如此我们就完成了倒序转正序的调换，利用这个例子来更好的了解数组是怎么作为函数参数的。

=========================================================================================================
今天就这。