C语言基础语法之数组

前言：
吾日三省吾身，吾写代码乎？吾思考乎？吾进取乎？

数组简介
所谓数组就是，数据类型相同的元素的集合。
在这里给大家介绍一下数组的类型，以及一维数组，二维数组。

一维数组基本语法

type_t arr_name [const_n];
type_t:指的是数组类型
const_n 是一个常量表达式，用来指定数组的大小

 //一维数组的创建
//代码一
int arr[10];
double arr[10];
char arr[10];
//不同类型数组的创建
 //代码二
int count = 10;
int arr[count];//这样的数组创建对吗？//err

代码二这样创建一个一维数组在vs里是err的，只有在有c99功能的编译器里才可以执行，因为在c99里边有变长数组的概念
在vs里创建数组时，[]里要给一个常量才可以，不能使用变量。

一维数组的初始化

数组的初始化：指的是数组在创建的同时，给数组内容安排合理的初始值即为初始化
代码如下：

 #include <stdio.h>
int  main()
{
     //整形数组在没有被完全初始化的时候，未被初始化的部分是数字 0，图示一
	int arr[10] = { 1,2,3,4 };
	 //字符型数组在没有被完全初始化的时候，为被初始化的部分是 '\0'，图示二
	char arr1[10] = { 'b','i','t' };
	//浮点型数组在没有被完全初始化的时候，未被初始化的部分是 0.0000，图示三
	double arr2[10] = { 3.14,1.12,5.12 }; 
	float arr3[10] = { 0.0 };
}

图一：

图二：

图三：

在这里我们要区分：

 char arr[] = "bit";
 char arr1[] = {'b','i','t' };

在内存中的存储方式：

 #include <stdio.h>
#include<string.h>
int  main()
{
	char arr[] = "bit";
	char arr1[] = {'b','i','t' };
	printf("%s\n", arr);
	printf("%d\n ", strlen(arr));
	printf("%s\n", arr1);
	printf("%d\n", strlen(arr1));
	return 0;
}

在计算字符串长度的时候，只有扫描到字符串的结束标志’\0’时，才算字符串的结束，在arr1中明显输出的是单个字符，所以在计算字符串大小的时候，结果为任意值。

一维数组的使用

 #include <stdio.h>
int main()
{
	int arr[10] = { 0 };//数组的不完全初始化
	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组的长度
	//对数组内容进行赋值，数组内容是从下标内容为零，来看是访问的
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		arr[i] = i;   //对数组内容进行赋值
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

数组数组是通过下标来访问的，下标从零开始；
数组大小是可以通过计算得到的
语法：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("&arr[%d] = %p\n", i, &arr[i]);
	}

	return 0;
}

输出结果：

相邻地址之间的16进制位，相差4个字节，也就是一个整形元素在内存中所占的字节长度，并且随着数组下标的增长，元素的地址也在随之增长，所以可以得出结论：数组在内存中是连续存放的

二维数组的基本语法

 int arr[2][2];
 char arr1[3][4];
 double arr2[2][2];
 int arr3[][3];

在二维数组中，行可以省略，但是列不可以省略

二维数组的初始化

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

二维数组的使用

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

输出结果：

二维数组在内存中的存储方式

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

第一行的最后一列，和第二行的第一列字节数也相差4个字节，所以的出结论：二维数组和一维数组在内存中的存储方式是一样的且都是连续存放。

数组作为函数参数

往往我们在写代码时，会把数组作为参数传给函数，比如要实现一个冒泡排序
算法思想：
例：降序排序
在整形数组中，相邻的两个数进行比较，把较小的数字向后移。
具体看图示：

有10个数字，
10个数字待排，数组内部交换9次
9个数字待排，数组内部交换8次
8个数字待排，数组内部交换7次
7个数字待排，数组内部交换6次
…
2个数字待排，数组内部交换1次

 #include <stdio.h>
void Buttle_Sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])  //数组内部数字交换
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
	Buttle_Sort(arr, sz);
	return 0;
}

这样的代码结构不够优化，如果原本的数组就是升序排序，这样的代码又要，在函数中执行交换，所以就降低的工作效率。
优化代码如下：

 #include <stdio.h>
void Buttle_Sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	int flag = 1;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			flag = 1;
			if (arr[j] > arr[j + 1])  //数组内部数字交换
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
	Buttle_Sort(arr, sz);
	return 0;
}

下一篇：实现三子棋游戏，敬请期待！