数组（基础）

已于 2023-08-06 17:34:35 修改
阅读量98 收藏
点赞数 3
分类专栏： C语言 文章标签： 数据结构 c语言 算法
于 2023-01-26 02:41:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73075027/article/details/128761146
版权

文章目录

数组的基础知识总结。

一维数组的创建和初始化

数组的创建

  • 数组：一组相同类型元素的集合。
  • 创建方式：
type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

#include <stdio.h>

//C99语法标准之前，数组大小必须是常量表达式指定
//C99语法标准中，引长变长数组的概念，变长数组中允许数组大小用变量来指定。

int main()
{
	int arr[8];
	char ch[10];
	float arr2[15];
	double arr3[3 + 5];

	return 0;
}
  • 数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。
  • C99语法标准之前，数组大小必须是常量表达式指定
    C99语法标准中，引长变长数组的概念，变长数组中允许数组大小用变量来指定。
#include<stdio.h>

int main()
{
	int n = 0;
	scanf("%d", &n);
	//创建数组
	int arr[n];//变长数组不能初始化
	int i = 0;
	for (i = 0; i < n; i++)
	{
		arr[i] = i;
	}
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
  • 注:在vs2019中是不支持变长数组概念的。
  • 由于代码块中scanf("%d", &n);，//n是变量，所以int arr[n];//变长数组不能初始化是变长数组，它的大小是不能进行初始化的。

数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

#include<stdio.h>
int main()
{
	int arr1[10] = { 1,2,3 };//不完全初始化，剩余的默认初始化为0
	int arr2[] = { 1,2,3,4 };
	int arr3[5] = { 1,2,3,4,5 };//完全初始化
	//字符数组
	char arr4[5] = { 'a','b', 99 };//----->'a','b','c', \0, \0
	char arr5[] = { 'a','b','c' };
	char arr6[10] = "abcdef";//------>a,b,c,d,e,f,\0,\0,\0
	return 0;
}
  • 数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。
  • 但是对于下面的代码要区分，内存中如何分配。
    如果数组初始化了，可以不指定数组的大小，数组的大小会根据初始化的内容来确定：如下：
#include<stdio.h>
int main()
{
	char arr1[] = "abc";//--->a b c \0
	char arr2[3] = { 'a','b','c' };// -----> a b c
	char arr3[] = { 'a','b','c' };// -----> a b c
	return 0;
}

差异：
在这里插入图片描述

一维数组的使用

  • 对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。
#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//              0 1 2 3 4 5 6 7 8 9
	printf("%d\n", arr[9]);
	return 0;
}
//结果：10

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

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

中的[]是**下标引用操作符**，与开头讲的变长数组是毫无关系的。

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//              0 1 2 3 4 5 6 7 8 9
	//printf("%d\n", arr[9]);
	printf("%d\n", sizeof(arr));
	
	return 0;
}

在这里插入图片描述

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//              0 1 2 3 4 5 6 7 8 9
	//printf("%d\n", arr[9]);
	printf("%d\n", sizeof(arr));

	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));

	
	return 0;
}

加粗样式

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//              0 1 2 3 4 5 6 7 8 9
	//printf("%d\n", arr[9]);
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(int[10]));


	/*int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));*/

	
	return 0;
}

数组也是有类型的。
在这里插入图片描述

总结
  1. 数组是使用下标来访问的，下标是从0开始。
  2. 数组的大小可以通过计算得到。

一维数组在内存中的存储

下面我们通过一组代码来看数组元素的地址：

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

&arr[0] = 0019F8E0
&arr[1] = 0019F8E4
&arr[2] = 0019F8E8
&arr[3] = 0019F8EC
&arr[4] = 0019F8F0
&arr[5] = 0019F8F4
&arr[6] = 0019F8F8
&arr[7] = 0019F8FC
&arr[8] = 0019F900
&arr[9] = 0019F904

在这里插入图片描述

可以清晰的发现，相邻两个元素之间都相差4

结论：
  1. 数组在内存中是连续存放的。
  2. 随着下标的增长，地址由低地址往高地址增长。
  • 那通过以上，我们能以此做什么呢？
#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];

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

00AFF9B4 == 00AFF9B4
00AFF9B8 == 00AFF9B8
00AFF9BC == 00AFF9BC
00AFF9C0 == 00AFF9C0
00AFF9C4 == 00AFF9C4
00AFF9C8 == 00AFF9C8
00AFF9CC == 00AFF9CC
00AFF9D0 == 00AFF9D0
00AFF9D4 == 00AFF9D4
00AFF9D8 == 00AFF9D8

在这里插入图片描述

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

二维数组的创建和初始化

二维数组的创建

矩阵

//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组的初始化

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

-注意：二维数组如果有初始化，行可以省略，列不能省略
在这里插入图片描述

二维数组的使用

  • 行和列皆是从0开始
    在这里插入图片描述
#include<stdio.h>
int main()
{

	int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
	int i = 0;
	for (i = 0; i < 3; i++)//0 1 2
	{
		//列
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%2d ", arr1[i][j]);//-2d
		}
		printf("\n");
	}
	return 0;
}

在这里插入图片描述

二维数组在内存中的存储

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

&arr[0][0] = 001FFB20
&arr[0][1] = 001FFB24
&arr[0][2] = 001FFB28
&arr[0][3] = 001FFB2C
&arr[1][0] = 001FFB30
&arr[1][1] = 001FFB34
&arr[1][2] = 001FFB38
&arr[1][3] = 001FFB3C
&arr[2][0] = 001FFB40
&arr[2][1] = 001FFB44
&arr[2][2] = 001FFB48
&arr[2][3] = 001FFB4C

在这里插入图片描述在这里插入图片描述

数组越界

  • 数组的下标是有范围限制的。
  • 数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。
    所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
  • C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。
    所以要做好越界的检查。
    在这里插入图片描述
  • 二维数组的行和列也可能存在越界。

数组作为函数参数

冒泡排序函数的错误设计

  • 对一个乱序数组进行升序排序，我们会用到冒泡排序，一般是用bubble_sort()。
  • 思路：
    在这里插入图片描述
    那么我们可以得出以下代码：
#include<stdio.h>

void bubble_sort(int arr[])
{
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	//冒泡排序的躺数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		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;
			}
		}

	}
}

int main()
{
	int arr[] = { 3,1,5,9,2,4,7,6,8,0 };
	//排序-升序
	//冒泡排序
	bubble_sort(arr);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ar[i]);
	}
	return 0;
}

但是：
在这里插入图片描述
并没有解决问题。这是个错误的冒泡排序。
在这里插入图片描述
难道数组作为函数参数的时候，不是把整个数组的传递过去？

数组名

一般来说，数组名是数组名首元素的地址。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);

	return 0;
}

00F3F748
00F3F748

但是

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	//printf("%p\n", arr);
	//printf("%p\n", &arr[0]);
      printf("%d\n",sizeof(arr));
	return 0;
}
//输出结果：40
//并不是我们预想中的4或者8
//所以这里是有问题的

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n\n", arr + 1);

	printf("%p\n", &arr[0]);
	printf("%p\n\n", &arr[0] + 1);

	printf("%p\n", &arr);
	printf("%p\n\n", &arr + 1);

	return 0;
}

00F1FB6C
00F1FB70

00F1FB6C
00F1FB70

00F1FB6C
00F1FB94

在这里插入图片描述

  • 所以：一般来说，数组名是数组名首元素的地址。
  • 但是有2个例外：
  1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
  2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
  • 除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

冒泡排序函数的正确设计

#include<stdio.h>
    //语法上可以是数组，但是本质：int * arr
void bubble_sort(int arr[],int sz)
{
	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
	        //sizeof(arr)算的是一个指针的大小
	//冒泡排序的躺数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		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;
			}
		}

	}
}

int main()
{
	int arr[] = { 3,1,5,9,2,4,7,6,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序-升序
	//冒泡排序
	bubble_sort(arr,sz);//arr是数组首元素地址，即 3的地址
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

接下来会逐步更新关于数组的两个实例：三子棋，扫雷以及汉诺塔，青蛙跳台。敬请期待，共同进步！

日夜无休时
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌--Java入门 - 数组基础
m0_56638814的博客
04-30 5393
头歌--Java入门 - 数组基础
Educoder题目：Java入门 - 数组基础答案解析
bingeho的博客
11-01 3643
初识数组 chapter7/src/step1/HelloWorld.java package step1; public class HelloWorld { public static void main(String[] args) { /********** Begin **********/ int[] array = {91,88,60}; System.out.println("数组的第一个值为：" + array[0] ); //在这里输出数
数组基础
少说，多做。
02-21 2690
  数组定义：   感觉还是挺好理解的。 考研例题： 画画图就很清楚了。 数组的顺序表示标准实现 typedef struct{ ElemType *base; //存放元素的基址 int dim; //维数 int *bounds; //等价整型数组，存各维长度 int *c...
JAVA数组基础
qq_62574400的博客
11-28 1010
一、数组： 　　数组指一组数据的集合，数组中的每个数据被称作元素。 二、数组定义： 　　类数组型[] 数组名 = new 数组类型[元素个数或数组长度]； （注意：等号前面的[]里面不能写任何东西） 也可以以下写法： 　　数组类型[] 数组名 = {元素，元素，....}； 用‘“数组名.length”的方式来获得数组的长度，即元素的个数。 三、数组的遍历： public class a{ public static void main(String[]args){
Educoder/头歌JAVA实训——JAVA入门：数组基础
舟舟的博客
12-18 7139
在开发中会经常涉及到大量数据的运用和计算，那这个时候什么能帮助我们来解决大量数据运算和存储的问题呢？ 这就需要用到 Java 中的数组了，数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 让我们通过本实训的训练来学习 Java 数组的创建和使用吧。
头歌（educoder）第 3 章 Java入门之数组 Java入门 - 数组基础
qq_35353972的博客
09-19 9958
头歌（educoder）第 3 章 Java入门之数组 Java入门 - 数组基础
Java入门 - 数组基础
热门推荐
wangyongqi的博客
01-15 1万+
第1关：初识数组 任务描述 本关任务：定义数组，使用数组。 相关知识 问：道友，我要保存4名学生的考试成绩，怎么办？ 答：简单啊，定义四个变量呗。 问：那“计算全年级500名学生的考试成绩的平均值”，怎么办？ 答：。。。。 数组：我来。 数组是什么 如果说我们之前使用的变量可以比作是一个装水的杯子，那么数组你可以看做是一个杯架（只能装一种杯子的杯架）。 怎么定义数组 变量类型[] 数组名 = {数据1,数据2,数据3,…}; 怎么访问数组中的元素 访问数组中的元素使用：数组名[索引值]，索引值一般也叫做
【C++保姆级入门】一维数组基础详解+习题巩固
iecne的博客
07-30 1489
新手必学会的教程—— 一维数组基础教程
数组基础知识
m0_55299825的博客
07-09 1567
数组格式 int [ ] arr :定义一个int类型的数组，名字叫arr。一般都用这种格式。 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。 格式：数据类型 [ ] 变量名 = new 数据类型[ 数组长度]； 示例： int [ ] arr = new int [3]; int : 说明数组中的元素类型是 int类型 [ ]: 说明这是一个数组 arr: 这个数组的名称 new： 为数组申请内存空间，创建对象 int： 说明数组中的元素类型是 int类型 [ ]: 说.
JAVA头歌实训 Java入门 - 数组基础
banana_778的博客
11-29 2285
在实际考试中我们不止考试一门而是多门，那么多门考试的成绩我们需要用编程语言来处理时，我们怎么保存这些数据呢？如果说我们之前使用的变量可以比作是一个装水的杯子，那么数组你可以看做是一个杯架（只能装一种杯子的杯架）。访问数组中的元素使用：数组名[索引值]，索引值一般也叫做数组的下标。平台会对您的代码进行运行测试，如果实际输出与预期输出相同，则算通关。平台会对你编写的代码进行测试：若与预期输出相同，则算通关。问：道友，我要保存4名学生的考试成绩，怎么办？本关任务：定义二维数组，输出二维数组中的数据。
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
java数组基础详解
08-28
java数组基础详解 Java数组是Java编程语言中的一种基本数据结构，用于存储相同类型的数据。数组是一个对象，包含多个元素，每个元素都是相同类型的数据。Java数组可以通过多种方式进行初始化，包括静态初始化和动态...
数组基础题目作业大纲.doc
05-08
数组是编程语言中基本的数据结构之一，用于存储一组...通过这些数组基础题目，学生可以更好地理解数组的性质和操作，为更复杂的编程任务打下坚实的基础。实践中应注重逻辑思维、算法设计和错误处理，以提高编程能力。
Java中的数组基础知识学习教程
09-02
Java中的数组基础知识是每个Java程序员必须要掌握的重要概念。数组是一种数据结构，允许我们存储相同类型的元素集合，并且在内存中是连续存储的。这使得数组访问速度快，因为可以通过索引来直接定位元素。数组的大小...
JAVA数组基础教程完整版
03-14
java数组 Java 语言中提供的数组是用来存储固定大小的同类型元素。 如：可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量...本资源是java数组基础教程，适合自学的朋友，有兴趣可以下载学习参考。
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 668
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
集合及数据结构第十节（下）————常用接口介绍、堆的应用和java对象的比较
2301_79418684的博客
08-25 806
常用接口介绍和堆的应用 1. PriorityQueue的特性 2. .PriorityQueue常用接口介绍 3. top-k问题 4. 堆排序 5. PriorityQueue中插入对象 6. 元素的比较 7. .对象的比较 8. .集合框架中PriorityQueue的比较方式
【数据结构】队列(Queue)
最新发布
xiaochuan_bsj的博客
08-28 556
数组，双链表实现队列，附完整代码
数据结构之链表
WSH2012ffff的博客
08-27 623
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
java 数组基础练习
09-18
数组基础练习包括数组的创建和初始化、数组的遍历和元素查找等操作。对于上述要求，你可以使用两次遍历来实现去掉0项并存入新数组的功能。首先，你可以遍历一次原数组来确定新数组的长度，即统计原数组中不为0的元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值