C语言之数组

月亮夹馍干

于 2022-11-20 10:17:51 发布

阅读量188

点赞数 1

分类专栏： C语言文章标签： c语言算法

本文链接：https://blog.csdn.net/m0_64238541/article/details/127937000

版权

C语言专栏收录该内容

35 篇文章 0 订阅

订阅专栏

学习数组，我们首先要弄清楚一维数组，由简入难。

1.一维数组的创建和初始化

1.1数组的创建

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

数组形式：type_t arr_name [const_n]

type_t :是数组元素类型

arr_name:数组名

[const_n]:是一个常量表达式，用来指示数组的大小。

例如：int arr[10]

1.2数组初始化

请看注释：

#include<stdio.h>
int main()
{
	int arr1[10] = { 0 };//创建的同时，使每个数组初始化为0
	int arr2[10] = { 1,2,3,4,5 };//不完全初始化，剩余元素默认初始化为0，10个元素
	int arr3[] = { 1,2,3,4,5,6,7 };//没有指定数组元素个数，编译器会根据初始化
	                                 //内容来确定数组元素个数，则这个数组有7个元素
	int arr4[3] = { 1,2,3 };//完全初始化，数组每个下标对应一个值

	char arr5[10] = { 'a','b','c','d','e' };//字符型，10个元素
	char arr6[] = { 'a','b','c' };//3个元素
	char arr7[10] = "abc";//10个元素
	char arr8[] = "abc";//4个元素，还有一个'\0'
	return 0;
}

2.一维数组的使用

1.数组是有下标的，下标从0开始；

2.[]是下标访问操作符。

#include<stdio.h>
int main()
{
	int arr[10] = { 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-1; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	//跳着打印
	for (i = 0; i < sz - 1; i+=2)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	//倒序打印
	for (i = sz-1 ; i >=0; i--)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

3.一维数组在内存中的存储

1.一维数组在内存中是连续存放的；

2.随着数组下标的增长，地址是由低到高变化的。

4.二维数组的创建和初始化

4.1二维数组的创建

类比与一维数组的创建：

int arr[3][4]:它的意思是这个二维数组3行4列，可以存储12个元素；

二维数组的下标也是从 0开始。

4.2二维数组初始化

请看注释解释：

#include<stdio.h>
int main()

{
	int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };//完全初始化,3行4列
	//（1,2,3,4）
	//（5,6,7,8）
	//（9，10,11,12）
	int arr2[3][4] = { 1,2,3,4,5 };//不完全初始化，剩余元素默认补0；即
	//(1,2,3,4)
	//(5,0,0,0)
	//(0,0,0,0)
	int arr3[3][4] = { {1,2},{3,4},{5,6} };//每行初始化规定好的元素后，剩余元素补0；
	//即：  (1,2,0,0)
	//      (3,4,0,0)
	//      (5,6,0,0)
	int arr4[][4] = { 1,2,3,4,5,6,7,8,9 };//二维数组行是可以省略的，但是列不可以；
	//它的初始化可以确定是4列，然后依次分配元素，按我上面的例子就是3行。
	//即：（1,2,3,4,）
	//    （5,6,7,8）
	//    （9,0,0,0）
	return 0;
}

5.二维数组在内存总的存储

关于二维数组在内存中的存储，我们可以通过一段代码来解释：

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

通过这段代码，我们可以看到：

我们发现，二维数组元素在内存中都是连续的，所以二维数组和一维数组一样，它在内存中是连续存放的，并且随着数组下标的增长，地址是由低到高变化的。

6.数组越界

1.数组下标是由限制范围的；

2.数组下标规定从0开始，如果数组有n个元素，最后一个元素的下标为n-1,如果数组元素下标<0或者>n-1，就是数组越界访问了，超出数组合法空间访问。

7.数组作为函数参数

数组作为函数参数，我们用一段代码例子来说：写一个函数对数组进行排序，要求升序。

我们用冒泡排序：冒泡排序就是比较相邻位置数字的大小，再按我们的要求进行排列。


#include<stdio.h>
void Sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)//比较躺数
	{
		int flag = 0;
		for (j = 0; j <sz - 1 - i; j++)//每趟需要比较的对数
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j+ 1];
				arr[j+ 1] = tmp;
				flag = 1;
			}
		}
		if (flag == 0)
			break;
	}
}
int main()
{
	int arr[] = { 2,5,3,8,1,4,6,9,10,7 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}