首页 > 其他分享 >数组

数组

时间：2024-10-19 15:18:27浏览次数：3  
标签：初始化 arr int 元素 二维 数组

数组

目录​

  1. 数组的概念

  2. 数组的概念

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

  4. 一维数组的使用

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

  6. sizeof计算数组元素个数​

  7. 二维数组的创建

  8. 二维数组的初始化

  9. 二维数组的使用

  10. 二维数组在内存中的存储

  11. C99中的变长数组​

  12. 数组练习​

1. 数组的概念

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

从这个概念中我们就可以发现2个有价值的信息：

  • 数组中存放的是1个或者多个数据，但是数组元素个数不能为0。
  • 数组中存放的多个数据，类型是相同的。

数组分为一维数组和多维数组，多维数组一般比较多见的是二维数组。

2. 一维数组

2.1 一维数组的创建与初始化

2.1.1 数组的创建

type arr_name[常量值];
//type：存放数据的类型
//arr_name：数组的名字
//[]中的常量值为元素个数，用于指定数组的大小

2.1.2 数组的初始化

数组的初始化一般使用大括号，将数据放在大括号中。

//完全初始化
int arr[5] = {1,2,3,4,5};
//数组完全初始化，则[]中的常量值可以省略

//不完全初始化
int arr[5] = {1,2,3)
//剩余元素默认初始化为0 

//字符串的初始化
//完全初始化
char str[5] ="hello";
char str[] = {'h', 'e', 'l', 'l', 'o'};
//不完全初始化
char str[10] = "hello";
//剩余元素用\0补齐

2.1.3 数组的类型

数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。

int arr[10];
char str[5];

arr数组的类型是 int [10]

str数组的类型是 char [5]

2.2 一维数组的使用

一维数组可以存放数据，存放数据的目的是对数据的操作，那我们如何使用一维数组呢？

2.2.1 数组下标

C语言规定数组是有下标的，下标是从0开始的，假设数组有n个元素，最后一个元素的下标是n-1，下标就相当于数组元素的编号，如下：

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
数组123456789
下标012345678

在C语言中数组的访问提供了一个操作符 []，这个操作符叫：下标引用操作符。其中 arr 与常量值为操作数。

有了下标访问操作符，我们就可以轻松的访问到数组的元素了，比如我们访问下标为 i的元素，我们就可以使用 arr[i] ，想要访问下标是 i的元素。

#include<stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	printf("%d", arr[3]);//输出4
	return 0;
}

2.2.2 数组元素的输入与输出

#include<stdio.h>
int main()
{
	int arr[5] = { 0 };
	int i = 0;
	//输入
	for (i = 0; i < 5; i++)
		scanf("%d", &arr[i]);//输入 1 2 3 4 5
	//输出
	for (i = 0; i < 5; i++)
		printf("%d ", arr[i]);//输出 1 2 3 4 5
	return 0;
}


//输入的另一种方式
#include<stdio.h>
int main()
{
	int arr[5] = { 0 };
	int i = 0;
	for (i = 0; i < 5; i++)
		scanf("%1d", &arr[i]);//输入 12345
	for (i = 0; i < 5; i++)
		printf("%d ", arr[i]);//输出 1 2 3 4 5
	return 0;
}

2.3 一维数组在内存中的存储

如果我们要深入了解数组，我们最好能了解一下数组在内存中的存储。

依次打印数组元素的地址：

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

//输出结果
&arr[0] = -745146376
&arr[1] = -745146372
&arr[2] = -745146368
&arr[3] = -745146364
&arr[4] = -745146360

从输出的结果我们分析，数组随着下标的增长，地址是由小到大变化的，并且我们发现每两个相邻的元素之间相差4（因为一个整型是4个字节）。所以我们得出结论：数组在内存中是连续存放的。

数组123456789
下标012345678

2.4 sizeof计算数组元素个数

在遍历数组的时候，我们经常想知道数组的元素个数。

sizeof是一个关键字，是可以计算类型或者变量大小的，其实 sizeof也可以计算数组的大小。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d", sizeof(arr));
	return 0;
}
//输出40，计算的是数组所占内存空间的总大小，单位是字节。

我们又知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能算出来。这里我们选择第一个元素算大小就可以。

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d", sizeof(arr) / sizeof(arr[0]));
	return 0;
}
//这里的结果是：10，表示数组有10个元素。

以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎么变化，计算出的大小也就随着变化了。

3. 二维数组

前面学习的数组被称为一维数组，数组的元素都是内置类型的，如果我们把一维数组做为数组的元素，这时候就是二维数组，二维数组作为数组元素的数组被称为三维数组，二维数组以上的数组统称为多维数组。

  • 数组元素

    1

  • 一维数组

    12345

  • 二维数组

    12345
    23456
    34567

3.1 二维数组的创建与初始化

3.1.1 二维数组的创建

那我们如何定义二维数组呢？语法如下：

type arr_name[常量值1][常量值2];

//type：存放数据的类型
//arr_name：数组的名字
//[]中的常量值1为数组的行数
//[]中的常量值2为数组的列数

3.1.2二维数组的初始化

那二维数组如何初始化呢？像一维数组一样，也是使用大括号初始化的。

//完全初始化
int arr[3][5] = {1,2,3,4,5,2,3,4,5,6,3,4,5,6,7};
12345
23456
34567
//不完全初始化
int arr[3][5] = {1,2};
12000
00000
00000
//按照行初始化
int arr[3][5] = {{1,2},{2,3},{3,4}};
12000
23000
34000

初始化时可以省略行， 但是不能省略列

int arr[][5] = {1,2,3};
12300
int arr[][5] = {1,2,3,4,5,6,7};
12345
67000
int arr[][5] ={{1,2},{3,4},{5.6};
12000
23000
34000

3.2 二维数组的使用

3.2.1 二维数组的下标

其实二维数组访问也是使用下标的形式的，二维数组是有行和列的，只要锁定了行和列就能唯一锁定数组中的一个元素。

C语言规定，二维数组的行是从0开始的，列也是从0开始的，如下所示：​

01234
012345
123456
234567
#include<stdio.h>
int main()
{
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	printf("%d", arr[2][4]);//输出 7
	return 0;
}

3.2.2 二维数组的输入和输出

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

//输入
2 2 2 2 2 3 3 3 3 3 4 4 4 4 4
//输出
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4

3.3 二维数组在内存中的存储

像一维数组一样，我们如果想研究二维数组在内存中的存储方式，我们也是可以打印出数组所有元素的地址的。代码如下：

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

//输出
&arr[0][0] = -744883416
&arr[0][1] = -744883412
&arr[0][2] = -744883408
&arr[0][3] = -744883404
&arr[0][4] = -744883400
&arr[1][0] = -744883396
&arr[1][1] = -744883392
&arr[1][2] = -744883388
&arr[1][3] = -744883384
&arr[1][4] = -744883380

从输出的结果来看，每一行内部的每个元素都是相邻的，地址之间相差4个字节，跨行位置处的两个元素（如：arr[0][4]和arr[1][0]）之间也是差4个字节，所以二维数组中的每个元素都是连续存放的。

4. C99中的变长数组

在C99标准之前，C语言在创建数组的时候，数组大小的指定只能使用常量、常量表达式，或者如果我们初始化数据的话，可以省略数组大小。

int arr[10];
int arr[3+5];

这样的语法限制，让我们创建数组就不够灵活，有时候数组大了浪费空间，有时候数组又小了不够用的。

C99中给一个变长数组（variable-length array，简称 VLA）的新特性，允许我们可以使用变量指定

数组大小。

请看下面的代码：

int n = 3 + 5;
int arr[n];

变长数组的根本特征，就是数组长度只有运行时才能确定，所以变长数组不能初始化。

它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。

变长数组的意思是**数组的大小是可以使用变量来指定的，在程序运行的时候，根据变量的大小来指定数组的元素个数，而不是说数组的大小是可变的。**数组的大小一旦确定就不能再变化了。

在VS2022上，虽然支持大部分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++)
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
  1. 数组练习​

练习1：多个字符从两端移动，向中间汇聚​

编写代码，演示多个字符从两端移动，向中间汇聚

1 #include<stdio.h>

2 intmain()

3 {

4 char arr1[] = “welcome to bit…”;

5 char arr2[] = “#################”;

6 int left = 0;

7 int right = strlen(arr1)-1;

8 printf(“%s\n”, arr2);

9 while(left<=right)

10 {

11 Sleep(1000);

12 arr2[left] = arr1[left];

13 arr2[right] = arr1[right];

14 left++;

15 right–;

16 printf(“%s\n”, arr2);

17 }

18 retutn 0;

19 }

20

比特就业课官网链接：ht t ps: //w w w . bi t ej i uyeke. com

比特就业课主页：ht t ps: //m . cct al k. com /i nst /s9yew hf r

练习2：二分查找​

在一个升序的数组中查找指定的数字n，很容易想到的方法就是遍历数组，但是这种方法效率比较低。​

比如我买了一双鞋，你好奇问我多少钱，我说不超过300元。你还是好奇，你想知道到底多少，我就让

你猜，你会怎么猜？你会1，2，3，4…这样猜吗？显然很慢；一般你都会猜中间数字，比如：150，然

后看大了还是小了，这就是二分查找，也叫折半查找。

1 #include<stdio.h>

2

3 intmain()

4 {

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

6 int left = 0;

7 int right = sizeof(arr)/sizeof(arr[0])-1;

8 int key = 7;//要找的数字​

9 int mid = 0;//记录中间元素的下标​

10 int find = 0;

11 while(left<=right)

12 {

13 mid = (left+right)/2;

14 if(arr[mid]>key)

15 {

16 right = mid-1;

17 }

18 elseif(arr[mid] < key)

19 {

20 left = mid+1;

21 }

22 else

23 {

24 find = 1;

25 break;

26 }

27 }

28 if(1 == find )

29 printf(“找到了,下标是%d\n”, mid);

30 else

31 printf(“找不到\n”);

32 }

求中间元素的下标，使用mid = (left+right)/2 ，如果left和right比较大的时候可能存在问

题，可以使用下面的方式：

1 mid = left+(right-left)/2;比特就业课官网链接：ht t ps: //w w w . bi t ej i uyeke. com

比特就业课主页：ht t ps: //m . cct al k. com /i nst /s9yew hf r

完

比特就业课官网链接：ht t ps: //w w w . bi t ej i uyeke. com

标签：初始化,arr,int,元素,二维,数组
From： https://blog.csdn.net/encoconut/article/details/143079200

相关文章

  • 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一
    这里写目录标题问题详情分析问题代码展示问题详情剑指Offer56：一个整型数组nums里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。示例：输入：nums=[4,1,4,6]输出：[1,6]或[6,1]分析问题......
  • 数组的定义和初始化
    一、数组的定义数组：是一块连续固定大小的内存空间，有着索引的概念定义数组的语句格式：数据类型[]数组名;【推荐】数据类型数组名[];二、数组的静态初始化/*如果只是定义一个数组的话，没有给初始化值，相当于一个变量没有值，是不能够直接使用的如何对一个数组......
  • 一.介绍函数指针数组 二.函数指针数组的使用
    一我们先来看这个这里面的四个函数都分别存放在函数指针变量中，而且这些函数的指针类型都一模一样那我们就可以搞出一个函数指针数组，来存放这些函数的地址 函数指针数组的写法从函数指针的基础上去写是最容易的想让他成为数组，我们可以在变量p后面加一个［］，p就和［］结合了，就说明......
  • IO流读写文件（字节流（单个字节，字节数组），字节缓冲流（..），字符流(..)，字符缓冲流(..)）
    IO流【输入输出流】：按照流向划分：输入流：外部数据->java程序输出流：java程序->外部数据按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：字节流【万能流】：字节输出流：......
  • 交错数组 二维数组 参数
    internalclassProgram{staticvoidMain(string[]args){int[,]arr=CreateArr();//int[,]arr1={{1,2},{2,3}};二维数组中不能使用new关键字//int[][]arr2={newint[]{}};交错数组......
  • c#数组案例（较复杂）两个数组合并、去重和取交集
    usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;namespace_01_数组{internalclassProgram{staticvoidMain(string[]args){//1.合并两个数组......
  • while循环和do循环、缓冲区、一维数组
    缓冲区输入缓冲区从键盘得到数据的时候用户输入的数据首先进入输入缓冲区，然后程序从输入缓冲区里获得数字，先进入输入缓冲区的数据必须先处理（类似排队），如果先进入输入缓冲区的数据无法处理，程序就得不到后进入输入缓冲区的数据。使用以下两条固定语句可以删除输入缓冲区里的无效数......
  • 3191. 使二进制数组全部等于 1 的最少操作次数 I
    给你一个二进制数组nums。你可以对数组执行以下操作任意次（也可以0次）：选择数组中任意连续3个元素，并将它们全部反转。反转一个元素指的是将它的值从0变1，或者从1变0。请你返回将nums中所有元素变为1的最少操作次数。如果无法全部变成1，返回-1。示例......
  • 二维数组的简单用法
    publicclassIntArrayDemo{publicstaticvoidPrint(){for(inti=0;i<IntArray.Ints.Length;i++){Console.WriteLine(i);}}publicstaticvoidGetValue(......
  • 力扣349.两个数组的交集
    题目链接：349.两个数组的交集-力扣（LeetCode）给定两个数组 nums1 和 nums2 ，返回 它们的 交集。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。示例1：输入：nums1=[1,2,2,1],nums2=[2,2]输出：[2]示例2：输入：nums1=[4,9,5],nums2=[......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99