c语言学习 (四) 数组

已于 2022-07-01 21:57:15 修改
阅读量270 收藏 1
点赞数
分类专栏： c语言学习 文章标签： 学习 c语言
于 2022-05-25 23:31:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mayu_xuan/article/details/124927607
版权

目录

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

1.1数组的创建

1.2数组的初始化

2.一位数组的使用

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

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

4.1二维数组的创建

4.2二维数组的初始化

5.二维数组的使用

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

7.数组作为函数参数

8.数组的应用实例1.三子棋

9.数组的应用实例2.扫雷游戏

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

1.1数组的创建

数组是一组相同类型的元素的集合。数组的创建方式：

type_t arr_name[const_n];

type_t 是指数组的元素类型。

arr_name 是数组名

const_n 是一个常量表达式，用来指定数组的大小。

#include<stdio.h>
int main()
{
	//代码1
	int arr1[10];

	//代码2
	int count = 10;
	int arr2[count];

	//代码3
	char arr3[10];
	float arr4[1];
	double arr5[20];
	return 0;
}

注：数组创建，[]中要给一个常量才可以，不能使用变量。

1.2数组的初始化

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

int arr1[10] = {1,2,3};

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

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

char arr4[3] = {'a',98,'c'};

char arr5[] = {'a','b','c'};

char arr6[[ = "abcdef";

数组在创建的时候如果想不指定数组的大小就得初始化。数组的元素个数根据初始化的内容来确定。但是对于下面的代码要区分，内存中如何分配。

char arr1[] = "abc";

char arr2[3] = {'a','b','c'};

arr1比arr2多个'\0';

2.一位数组的使用

对于数组的使用我们之前介绍了一个操作符[]，下标引用操作符。它其实就数组访问的操作符。我们来看代码：

#include<stdio.h>
int main()
{
	int arr[10] = {0};//数组的不完全初始化
	//计算数组的元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	//对数组内容赋值，数组是使用下标来访问的，下标从0开始，所以：
	int i = 0;//做下标
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
	}
	//输出数组的内容
	for(int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 总结：

1.数组是使用下标来访问的，下标是从0开始。

2.数组的大小可以通过计算得到。

int arr[10];

int sz = sizeof(arr) / sizeof(arr[0]);

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

接下来我们探讨数组在内存中的存储。看代码：

#include<stdio.h>
int main()
{
	int arr[10] = {0};//数组的不完全初始化
	//计算数组的元素个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	//对数组内容赋值，数组是使用下标来访问的，下标从0开始，所以：
	int i = 0;//做下标
	for (i = 0; i < sz; i++)
	{
		arr[i] = i;
	}
	//输出数组的内容
	for(int i = 0; i < sz; i++)
	{
		printf("&arr[%d] = %p\n", i,&arr[i]);
	}
	return 0;
}

 仔细观察输出结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。由此可以得出结论：数组在内存中是连续存放的。

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

4.1二维数组的创建

//数组创建

int arr[3][4];

char arr[3][5];

double arr[2][4];

4.2二维数组的初始化

//数组初始化

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

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

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

5.二维数组的使用

二维数组的使用也是通过下标的方式。看代码：

#include<stdio.h>
int main()
{
	int arr[3][4] = {0};
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (int j = 0; j < 4; j++)
		{
			arr[i][j] = i * 4 + j;
		}
	}
	//输出数组的内容
	for (i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

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

像一维数组一样，这里我们尝试打印二维数组的每个元素。

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

 

 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

7.数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序（这里要将算法思想）函数将一个整形数组排序，那我们将会这样使用该函数。

冒泡排序思路：

 冒泡排序代码：

#include<stdio.h>
void bubble_sort(int arr[],int sz)
{
	for (int i = sz; i >= 0; i--)
	{
		for (int j = 0; j < i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}
int main()
{
	int arr[] = {9,8,7,6,5,4,3,2,1,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	for (int i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	return 0;
}

数组名是什么？ 

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

 结论：

数组名是数组首元素的地址。（有两个例外）

如果数组名是首元素地址，那么：

int arr[10] = {0};

printf("%d\n", sizeof(arr));

为什么输出的结果是：40

补充：

1.sizeof(数组名),计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。

.2.&数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

除此1，2两种情况之外，所有的数组名都表示数组首元素的地址。

8.数组的应用实例1.三子棋

主函数文件：

#include"game.h"
void menu()
{
	printf("****************************\n");
	printf("*****1. play     0.exit*****\n");
	printf("****************************\n");
}
//游戏的整个算法实现
void game()
{
	char ret = 0;
	//数组存放走出的期盼信息
	char board[ROW][COL] = { 0 };
	//初始化棋盘
	InitBoard(board, ROW, COL);
	//打印棋盘
	DisplayBoard(board,ROW,COL);
	//下棋
	while (true)
	{
		//玩家下棋
		PlayerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断玩家是否赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		//电脑下棋
		ComputerMove(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		//判断电脑是否赢
		ret = IsWin(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	if (ret == '*')
		printf("玩家赢\n");
	else if (ret == '#')
		printf("电脑赢\n");
	else
		printf("平局\n");
}
void test()
{
	int input;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择：>\n");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			printf("退出游戏");
			break;
		case 1:
			game();
			break;
		default:
			printf("输入有误,请输入0或1！");
			break;
		}
	} while (input);

}
int main()
{
	test();
	return 0;
}

game头文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 3
#define COL 3
void InitBoard(char board[ROW][COL], int row, int col);
void DisplayBoard(char board[ROW][COL], int row, int col);
void PlayerMove(char board[ROW][COL], int row, int col);
void ComputerMove(char board[ROW][COL], int row, int col);
char IsWin(char board[ROW][COL], int row, int col);
int IsFull(char board[ROW][COL], int row, int col);

 game文件：

#include"game.h"

void InitBoard(char board[ROW][COL], int row, int col)
{
	int i, j;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			board[i][j] = ' ';
		}
	}
}


void DisplayBoard(char board[ROW][COL], int row, int col)
{
	int i;
	for (i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			printf(" %c ",board[i][j]);
			if (j < col - 1)
				printf("|");
		}
		printf("\n");
		if (i < row - 1)
		{
			for (int j = 0; j < col; j++)
			{
				printf("---");
				if (j < col - 1)
					printf("|");
			}
			printf("\n");
		}	
	}
}


void PlayerMove(char board[ROW][COL], int row, int col)
{
	int x, y;
	printf("玩家走：\n");
	while (1)
	{
		printf("请输入要下的坐标：");
		scanf("%d%d", &x, &y);
		//判断x,y坐标合法性
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x - 1][y - 1] == ' ')
			{
				board[x - 1][y - 1] = '*';
				break;
			}
			else
			{
				printf("该坐标被占用\n");
			}
		}
		else
		{
			printf("坐标非法，请重新输入！\n");
		}
	}
}

void ComputerMove(char board[ROW][COL], int row, int col)
{
	printf("电脑走：\n");
	int x, y;
	while (1)
	{
		x = rand() % row;
		y = rand() % col;
		if (board[x - 1][y - 1] == ' ')
		{
			board[x - 1][y - 1] = '#';
			break;
		}
	}
	
}

int IsFull(char board[ROW][COL], int row, int col)
{
	int i, j;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			if (board[i][j] == ' ')
				return 0;//没满
		}
	}
	return 1;//满了
}

char IsWin(char board[ROW][COL], int row, int col)
{
	int i,j;
	//行判断
	for (i = 0; i < row; i++)
	{
		if (board[i][1] == board[i][0] && board[i][1] == board[i][2] && board[i][1] != ' ')  
			return board[i][1];
	}
	//列判断
	for (i = 0; i < row; i++)
	{
		if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ') 
			return board[1][i];
	}
	//对角线判断
	for (i = 0; i < row; i++)  
	{
		if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')
			return board[1][1];
		if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')
			return board[1][1];
	}
	//判断是否平局
	if (1 == IsFull(board, ROW, COL)) 
		return 'Q';
	return 'C';
}

9.数组的应用实例2.扫雷游戏

主函数文件

#include"game.h"
void menu()
{
	printf("************************\n");
	printf("********1. play*********\n");
	printf("********0. exit*********\n");
	printf("************************\n");
}

void game()
{
	//雷的信息储存
	//1.布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
	//2.排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//扫雷
	FindMine(mine, show, ROW, COL);
}

void test()
{
	int input;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}



int main()
{
	test();
	return 0;
}

game头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 9
#define COL 9
#define ROWS ROW + 2
#define COLS COL + 2
#define EASY_COUNT 10
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
void DisplayBoard(char board[ROWS][COLS], int row, int col);
void SetMine(char board[ROWS][COLS], int row, int col);
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, in

game文件

#include"game.h"
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i, j;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	//打印列号
	for (int i = 0; i <= row; i++)
		printf("%d ", i);
	printf("\n");
	for (int i = 1; i <= row; i++)
	{
		printf("%d ", i);
		for (int j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (board[x][y] == '0')
		{
			board[x][y] = '1';
			count--;
		}
	}
}

int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return mine[x - 1][y] +
		mine[x - 1][y - 1] +
		mine[x][y - 1] +
		mine[x + 1][y - 1] +
		mine[x + 1][y] +
		mine[x + 1][y + 1] +
		mine[x][y + 1] +
		mine[x - 1][y + 1] - 8 * '0';
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x, y;
	int win = 0;
	while (win < row * col - EASY_COUNT)
	{
		printf("请输入排查雷的坐标：");
		scanf("%d%d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//坐标合法
			if (mine[x][y] == '1')//踩雷
			{
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, row, col);
				break;
			}
			else//不是雷
			{
				//计算x,y坐标周围有几个雷
				int count = get_mine_count(mine, x, y);
				show[x][y] = count + '0';
				DisplayBoard(show, row, col);
				win++;
			}
		}
		else
		{
			printf("输入坐标非法，请重新输入!\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功");
	}
}

m_yx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言学习4 数组
mqs580的博客
03-19 205
一维数组: 定义方式 : 数据类型 数组名[常量表达式]； 例如: int a[10] float b[10] char c[10] 数组名表示内存首地址,是地址常量 编译时分配连续内存 内存字节数=数组维数* sizeof(元素数据类型) 初始化：int a[5]={1,2,3,4,5}; int a[]={1,2,3,4,5,6}; 编译系统根据初值个数确定数组维数 数组不...
C语言数组学习心得（一）
u013256925的专栏
04-03 9207
1.用数组名作为函数参数时，要求形参和相对应的实参都必须是类型相同的数组，都必须有明确的数组说明 2.用数组名作为函数参数，应在主调函数和被调函数中分别定义数组，且数据类型必须移植，否则结果将出错，形参数组中的[]必不可少，以表明该形参是一维数组 3.c编译系统对形参数组大小不做检查，所以形参数组可以不指定大小。 如果指定形参数组的大小，则实参数组的大小必须大于形参数组，否则因形参数组的部分元
【c语言基础】float型数组的定义，输出和输入问题
m0_58528895的博客
06-11 7283
前言：用的编码器是devc++ 5.11版本，不同的编译器可能有些地方不一样。输出时，不管在里面存的是整数还是小数，用%f输出的结果都是六位小数。float型数组的定义和int类型的数组定义的方法类似，float类型的数组定义的方法是：float a[5];int 类型的数组定义的方法是：int a[5];也可以给float类型的数组里放整型数据。如果用%d得到话，结果只会是0。一、float类型数组的定义。可以输入整型类型的数据。
函数原型
weixin_51625231的博客
11-02 721
1 #include<stdio.h> void sum(int begin,int end) { int i; int sum=0; for(i=begin;i<=end;i++){ sum+=i; } printf("%d到%d的和是%d\n",begin,end,sum); } int main() { int a,b; scanf("%d%d",&a,&b); sum(a,b); return 0; } 2 #include<std
浮点型数据的输入和输出（C语言）
热门推荐
weixin_46039719的博客
02-13 3万+
目录 1 浮点型数据的输入 1.1单精度输入 1.2双精度和长双精度 2 浮点型数据的输出 2.1浮点数的默认输出 2.2指定输出格式%m . n f 2.3输出示例 3 案例 3.1案例 1 浮点型数据的输入 1.1单精度输入 (1)格式1 格式控制符：%f、%e、%g（或%F、%E、%G） 示例：float f1,f2; scanf("%f%f",&f1,&f2); //%f可为%e或%g 如输入： 3.14159和5.3，输入格式...
C语言（函数指针数组）详解
Raikkonen_love的博客
08-23 1万+
指针，指针数组，数组指针，函数指针数组
c语言数组存放数组,C语言实现将一个数组中的奇偶数分别存放
weixin_39539733的博客
05-18 1775
在一个数组中的元素大多奇数和偶数是混在一起的，而将数组中元素奇数和偶数分开存放则是我们要解决的问题。将奇数和偶数分开存放然后打印出来的思路是先创建两个空间，将奇数和偶数分别存放起来，然后再将他们又存进原数组，最后将数组元素循环打印就完成了奇数和偶数的分别存放。#includeint main(){int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };int i = 0...
C语言函数——数组讲解
dongxue727504的博客
02-07 3368
C语言函数新篇章，数组讲解，再次踏上新的征程。
嵌套数组
singhwong
01-02 8124
要注意多维数组和嵌套数组二者之间的区别，嵌套数组也叫数组的数组，或者交错数组。通过以下方式来声明变量： int[3][2] arr; 就是数组中的每个元素也是数组，也就是数组里面也包含数组。如： //嵌套数组 char[][] ccs = new char[][] { new char[]{'a','b'}, new char[]{'c','d'},
深入浅出C语言——数组
weixin_55051736的博客
02-13 5435
另外，C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。数组在创建的时候如果想不指定数组的确定的大小就需要进行初始化，此时数组的元素个数根据初始化的内容来确定。二维数组的不完全初始化时，未初始化的元素默认为0。下标从0开始，arr[i]是访问数组的一个元素，i是用来指定数组的下标，使用变量是没有问题的。数组的下标是有范围限制的，如果数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
c语言float输入格式,[讨论]关于float类型的数组输入
weixin_42511507的博客
05-19 3164
[讨论]关于float类型的数组输入以下是几个简单的测试程序:1.#include "stdio.h"int main(void){int i=1;int j=2;int a[3][3];scanf("%d",&a[i][j]);printf("%d",a[i][j]);return 0;}2.#include "stdio.h"int main(void){int i=1;int j=2...
C语言学习笔记(五)：数组的使用
xf555er的博客
02-12 1183
/定义数组长度为10,数组类型为整型,数组名字为a printf("%d" , a [ 9 ]);//输出数组下标为9的元素, 即输出8//定义a为3×4(3行4列)的数组，b为5×10(5行10列)的数组 a [ 3 ] [ 4 ] = 8;//不存在a[3][4]元素,数组a可用的“行下标”的范围为0~2，“列下标”的范围为0~3 /*在引用数组元素时，下标值应在已定义的数组大小的范围内。*/
深入了解浮点型变量输入与输出
weixin_47712251的博客
05-13 4337
在 C 语言中，浮点型变量有两种类型：float 和 double。这两种类型的变量的区别在于精度和占用空间大小。float 变量占用 4 个字节，可以存储 7 位有效数字；double 变量占用 8 个字节，可以更精确地存储 15 位有效数字。通常情况下，使用 double 类型更为稳妥。在写程序时，我们应该非常注意浮点型变量的输入和输出。为了避免常见的错误，我们需要特别注意格式控制符、运算误差等问题，同时注意变量的数据范围，谨慎处理程序中的错误。
C_数组
Gzmy的博客
07-19 348
数组是一个相同数据类型的集合,里面可以存放int,char,float等等, type_t arr_name [const_n] 可以通过上面的方式来创建一个数组,首先是数组里面数据元素的类型,接着是数组名,最后方括号里面是数组的大小,注意方括号里面一定是个常量,不能使用变量. 初始化就是在创建数组的同时给定一组合理的值,如果在数组的创建过程中不想给定数组的大小,那就一定得初始化,元素的个...
C语言：数组(详解)
m0_74068921的博客
05-19 8662
数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。所以，数组是用于储存多个相同类型数据的集合。
C语言数组的读取
127.0.0.1的博客
03-15 1万+
#include <stdio.h> int main() { int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int a; for (a=0;a<10;a++) { printf("%d\n",arr[a]); } return 0; }
[C语言] 初始函数 & 数组
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
12-22 4166
​降低复杂性：使用函数的最首要原因是为了降低程序的复杂性，可以使用函数来隐 含信息，从而使你不必再考虑这些信息。 避免重复代码段：如果在两个不同函数中的代码很相似，这往往意味着分解工作有 误。这时，应该把两个函数中重复的代码都取出来，把公共代码放入一个新的通用函数中， 然后再让这两个函数调用新的通用函数。通过使公共代码只出现一次，可以节约许多空间。 因为只要在一个地方改动代码就可以了。这时代码也更可靠了。 限制改动带来的影响：由于在独立区域进行改动，因此，由此带来的影响也只限于 一个 或最多几个区域中。
C语言中的数组（详解）
最新发布
m0_68662723的博客
07-26 1万+
代码中 sizeof(arr)表示计算整个数组arr的大小，而sizeof(arr[0])表示计算数组中首元素的大小（随便计算一个元素就行，因为每个元素的大小都是相等的，这里是选取了首元素），所以sz就是数组元素的个数。对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符，即arr[0]为数组首元素，arr[4]为最后一个元素。C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
数组嵌套
liangxingfu0809的博客
07-18 4658
一个长为 N 且下标从 0 开始的数组 A 包含 从 0 到 N - 1 的所有整数。找到并返回集合 S 的最大长度，其中S [i] = {A [i]，A [A [i]]，A [A [A [i]]]，…}受到以下规则的约束。 假设 S 中的第一个元素以选择 index = i的元素A [i]开始，S中的下一个元素应该是A [A [i]]，然后是A [A [A [i]]] … 通过这个类比，我们在S...
C语言中的数组ppt课件.ppt
11-18
"C语言中的数组介绍，包括一维数组和二维数组的概念、声明、定义、初始化及引用方法。" 在C语言中，数组是一个...对于数组的理解和熟练运用是C语言学习的重要步骤，因为数组在各种算法和数据结构中都扮演着核心角色。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值