C语言中 数组的深入讲解（你确定不进来看看？）

• 什么是数组？
• • 一维数组的定义与初始化
  • • 数组初始化，是对谁初始化
    • • 数组能存储啥
      • 一维数组的访问
    • 对数组元素排序
    • • 冒泡排序
      • 选择排序
    • 二维数组
    • • 二维数组的定义与初始化
      • 初始化二维数组
      • 二维数组的遍历
    • 多维数组

数组是一个固定长度的存储相同类型的的数据结构，数组中的元素被存储在一段连续的内存空间中。它是最简单的数据结构之一

int[] array = 10

这样不就创建了一个长度为10的数组，数组是用来存放数据的

对于数组，人家是有序数据的集合，在内存中展示。就是人家需要连续的内存空间

一维数组指的只有一个下标的数组，它用来表示一组类型相同的数据
格式：

类型说明符 数组名[常量表达式];

在上面格式中，
类型说明符表示数组中所有元素的类型
常量表达式指的是数组的长度，也就是数组中存放元素的个数
下面定义一个大小为10的int类型数组：

int array[10];

其中，int是数组的类型，array[ ]是数组的名称，方括号[ ]中的10是数组的长度

定义一个数组只是为数组开辟了一块内存空间，这时如果想使用数组操作数据，还需要对数组进行初始化

数组初始化不是对数组变量初始化，而是对数组对象进行初始化，无非就是告诉内存，我要创建一个数组，你的给我分配一块连续的内存。

数组下标是从0开始的，数组这家伙是一个数据集合，有序的，而且每个数据的类型都是相同的，

一个大大的特点，人家支持随机访问，这个就是可以使用下标访问数组的特性

数组初始化的方式有三种：

1. 直接对数组中的元素进行赋值

int i[1]={1,2,3,4,5,6,7,8,9,10};

上述代码定义了一个长度为10的整型数组i，数组中的元素依次为1，2，3，4，5，6，7，8，9，10

2. 只对数组中的一部分元素进行赋值

int i[10]={1,2,3,4,5};

上述代码定义了一个长度为10的整型数组i,但在初始化时，只对数组中的前五个元素进行赋值，其他元素的值会被默认为0.
所以数组中的元素依次为1，2，3，4，5，0，0，0，0，0

3. 对数组全部元素赋值，但不指定长度

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

在上述代码中，数组i中的元素有5个，系统会根据给定初始化元素的个数定义数组的长度，因此数组的i长度为5

上面的每一个格子都可以看做是一个内存单元，现在我们创建的内存为10的整型数组，蓝色的即为我们所创建的数组，红色的表示被占用。

你创建什么类型的数组，你就存放什么类型的数据
数组其实是一个特殊的对象

一维数组的访问包括读取指定元素和遍历数组

1. 读取指定元素
   在程序中，我们需要访问数组中的一些元素，这时我们可以通过数组名和下标来访问数组中的元素
   格式：

数组名 [需要元素的下标]

2. 遍历一维数组
   依次访问数组中的每一个元素，这种操作称为数组的遍历

通常遍历数组只用循环语句实现，以数组的元素的下标作为循环条件，只要数组元素下标有效就可以获取数组元素

#include
int main(void)
{
	int a[10];//定义一个名字为a的整型数组，a中的元素有10个
	for(int i=0;i<10;i++)
	{
		a[i]=i;//为元素赋值
		printf("%dn",a[i]);//for循环遍历每一个元素
	}
	return 0;
}
运行结果
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9

冒泡即整个过程跟水中气泡上升的原理相似

原理：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来

此处引用网上一张比较经典的gif，我是在博主：解梦者看到的。。。。。,由这张图可以看出冒泡排序的整个过程：

其中最重要的格式：

for(i=0;i数组名[j+1])
		{
			temp=数组名[j];
			数组名[j]=数组名[j+1];//temp,我们交换时需要的中间变量，我们可以在最开始时定义一个变量 
			数组名[j+1]=temp;     //这个变用到量会在这里 
		}
	}
 } 

下面的这串代码列子一定要理解明白：

//当然这个版本是从小到大排的 
#include  
int number[100];  
int main()     
{
    int i,n,j,temp;
    printf("输入排序的数字个数：n");   
    scanf("%d",&n); 
    printf("输入%d个数:n",n);     
    for(int j=0;jnumber[j+1])   //排序的大小顺序这里改 ！！！
            {
                temp=number[j];     
                number[j]=number[j+1];    //如果前面的数大于后面的数，就交换两个元素的位置 
                number[j+1]=temp;
            }
        }
    }    
    for (i=0;i 
选择排序 
选择排序指每一次从待排序记录中选择出最大（小）的元素，将其依次放在数组的最前端或者最后端，来实现数组的排序。
 此处引用网上一张比较经典的gif，我是在博主：解梦者看到的。。。。。,由这张图可以看出选择排序的整个过程：
 
 其中最重要的格式
 
for(i=0;i 
#include
void SelectSort(int A[],int n); 

int main() 
{
	int A[1024],n;
	printf("请输入要输入的元素个数：");
	scanf("%d",&n);
	printf("n请输入要排序的序列：n");
	for (int i=1; i<=n; i++) //输入的元素从1开始，0做哨兵
		scanf("%d",&A[i]);
	printf("n使用简单选择排序算法后的结果：n");
	SelectSort(A,n);//函数调用 
	for(int i=1; i<=n; i++)
		printf("%dt",A[i]);
	printf("n");
	return 0;
}

void SelectSort(int A[],int n)
{
	for(int i=1;i<=n;i++)//外层循环控制比较的轮数 
	{
		int min=i;//暂定i下标的元素是最小的，用min来记录其下标值 
		for(int j=i+1;j<=n;j++)//内层循环在剩下的元素中找出最小的元素 
		{
			if(A[j] 
二维数组 
二维数组的定义与初始化 
二维数组是指维数为2的数组，即维数有两个下标；
 在内存中为二维数组分配一块连续的内存空间，
 空间的大小为行长度 * 列长度 * sizeof(数据类型）
 
类型说明符 数组名[常量表达式1（行长度）][常量表达式2（列长度）]
 
我们定义一个4行3列的二维数组
 
int arr[4][3];
 
可以看出数组元素在内存中以行为主序进行存储(先储存第一行第一个元素，第一行第二个元素，第一行第三个元素）依次类推
 
 
 
 
二维数组中的所有元素都存储在一片连续的内存单元中
 
 
//输入任意三行三列的二维数组，秋对角元素的和 
#include

int main() 
{
  int arr[3][3];
  int i, j, sum = 0;
  printf("请输入元素（用空格隔开）:n");
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 3; j++)
    {
      scanf("%d", &arr[i][j]);
    }
  }
  for (i = 0; i < 3; i++)
  {
    for ( j = 0; j < 3; j++)
    {
      if (i==j)
      {
        sum += arr[i][j];
      }
    }
  }
  printf("对角元素的和为: %dn", sum);
  return 0;
}
运行结果：：
请输入元素（用空格隔开）:
1 5 9
2 4 6
7 5 3
对角元素的和为: 8
 
初始化二维数组 
对二维数组定义后，需要对二维数组进行初始化，有四种情况：
 
按行给二维数组赋
 
int a[2][3]={{1,2,3},{4,5,6}};
 
上述代码中,等号后边有两个大括号，第一个大括号代表的是第一行的数组元素，第二个大括号代表的是第二行的数组元素
 
将所有的数组元素按行顺序写在一个大括号内
 
int a[2][3]={{1,2,3,4,5,6};
 
对部分数组元素赋初值
 
int b[3][4]={{1},{2,3},{4,5,6}}
 
上述代码中，只对部分元素进行了赋值，对于没有赋值的元素，系统会自动赋值，元素为0.
 
对所有元素赋值，可以省略行下标，但是列下标不能够省略。
 
 
 
列下标不能够省略
 
 
int a[2][3]={{1,2,3,4,5,6};
int a[][3]={{1,2,3,4,5,6};
 
二维数组的遍历 
和一维数组一样都是使用循环语句实现，但是二维数组有两个维度，需要使用双层循环，外层遍历二维数组的行，内层遍历二维数组的列。
 
#include 
#include 
int main(void){
    
    int a[3][4]={
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    int i,j;
    for (i=0; i<3; i++) {//外层循环控制行
        for (j=0; j<4; j++) {//内层循环控制列
            printf("%d,",a[i][j]);
        }
        printf("n");
    }
    return 0;
}
运行结果：
1,2,3,4,
5,6,7,8,
9,10,11,12,
 
多维数组 
多维数组在我们的日常，学习生活中并不常用，这里就不在叙述。
 
从现在做起，坚持下去，一天进步一小点，不久的将来，你会感谢曾经努力的你！ 
如果又出错的，请各位友友指正。
 
 
新人报到，各位友友们，给我个三联（点赞，关注，收藏）