【C语言回顾】数组

  • 前言
  • [1. 数组](#1. 数组)
  • [2. 一维数组](#2. 一维数组)
    • [2.1 一维数组的创建](#2.1 一维数组的创建)
    • [2.2 一维数组的初始化](#2.2 一维数组的初始化)
    • [2.3 一维数组的使用](#2.3 一维数组的使用)
      • [2.3.1 一维数组的下标](#2.3.1 一维数组的下标)
      • [2.3.2 一维数组的输入和输出](#2.3.2 一维数组的输入和输出)
    • [2.4 一维数组在内存中的存储](#2.4 一维数组在内存中的存储)
  • [3. 二维数组](#3. 二维数组)
    • [3.1 二维数组的创建](#3.1 二维数组的创建)
    • [3.2 二维数组的初始化](#3.2 二维数组的初始化)
    • [3.3 二维数组的使用](#3.3 二维数组的使用)
      • [3.3.1 二维数组的下标](#3.3.1 二维数组的下标)
      • [3.3.2 二维数组的输⼊和输出](#3.3.2 二维数组的输⼊和输出)
    • [3.4 二维数组在内存中的存储](#3.4 二维数组在内存中的存储)
  • [4. sizeof 计算数组元素个数](#4. sizeof 计算数组元素个数)
  • [5. 变长数组](#5. 变长数组)
  • [6. 练习强化](#6. 练习强化)
    • [6.1 练习](#6.1 练习)
    • [6.2 答案](#6.2 答案)
  • 结语

上期回顾: 【C语言回顾】分支和循环

前言

各位小伙伴,大家好!话不多说,我们直接进入正题。

以下是C语言数组的讲解。

1. 数组

【概念】数组是⼀组相同类型元素的集合。

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

【分类】数组分为一维数组、二维数组和多维数组。

2. 一维数组

2.1 一维数组的创建

c 复制代码
type arr_name[常量值];

int math[20];
char ch[8]; 
double score[10]; 

2.2 一维数组的初始化

c 复制代码
//完全初始化 
int arr[5] = {1,2,3,4,5}; 

//不完全初始化 
int arr2[6] = {1};//第⼀个元素初始化为1,剩余的元素默认初始化为0 

//错误的初始化 - 初始化项太多 
int arr3[3] = {1, 2, 3, 4};

2.3 一维数组的使用

2.3.1 一维数组的下标

C语⾔规定数组是有下标的,下标是从0开始的,假设数组有n个元素,最后⼀个元素的下标是n-1,下标就相当于数组元素的编号。

【示例】

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

【输出】

2.3.2 一维数组的输入和输出

【数组输入】

c 复制代码
#include <stdio.h>
int main()
{
        int arr[10] ={ 1,2,3,4,5,6,7,8,9,10 };
        int i = 0;
        for(i=0; i<10; i++)
        {
                scanf("%d",&arr[i]);
        }
        for(i=0; i<10; i++)
        {
                printf("%d ",arr[i]);
        }
        return 0;
}

【数组输出】

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

【输出】1 2 3 4 5 6 7 8 9 10

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

【依次打印数组元素的地址】

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


【结论】数组在内存中是连续存放的

3. 二维数组

数组的元素都是内置类型的,如果我们把⼀维数组做为数组的元素,这时候就是⼆维数组,⼆维数组作为数组元素的数组被称为三维数组,⼆维数组以上的数组统称为多维数组。

3.1 二维数组的创建

c 复制代码
type arr_name[常量值1][常量值2]; 

int arr[3][5]; 
double data[2][8]; 

【解释】

  • 表⽰数组有3⾏。
  • 5表⽰每⼀⾏有5个元素。
  • int 表⽰数组的每个元素是整型类型。
  • arr 是数组名,可以根据⾃⼰的需要指定名字。
  • data数组意思基本⼀致。

3.2 二维数组的初始化

c 复制代码
//不完全初始化
int arr1[3][5] = {1,2}; 
int arr2[3][5] = {0}; 

//完全初始化 
int arr3[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};

//按照行初始化
int arr4[3][5] = {{1,2},{3,4},{5,6}};

//初始化时省略⾏,但是不能省略列
int arr5[][5] = {1,2,3}; 
int arr6[][5] = {1,2,3,4,5,6,7}; 
int arr7[][5] = {{1,2}, {3,4}, {5,6}}; 

3.3 二维数组的使用

3.3.1 二维数组的下标

c 复制代码
int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7}; 
c 复制代码
#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\n", arr[2][4]); 
 return 0; 
} 

【输出】7

3.3.2 二维数组的输⼊和输出

c 复制代码
#include <stdio.h>
int main()
{
        int arr[3][5] ={ 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
        int i = 0;//遍历⾏
        //输⼊
        for(i=0; i<3; i++) //产⽣⾏号
        {
                int j = 0;
                for(j=0; j<5; j++) //产⽣列号
                {
                        scanf("%d",&arr[i][j]); //输⼊数据
                }
        }
        //输出
        for(i=0; i<3; i++) //产⽣⾏号
        {
                int j = 0;
                for(j=0; j<5; j++) //产⽣列号
                {
                        printf("%d ",arr[i][j]); //输出数据
                }
                printf("\n");
        }
        return 0;
}

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

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

【分析】从输出的结果上看,每⼀⾏内部的每个元素都是相邻的,地址之间相差4个字节,跨⾏位置处的两个元素(如:arr[0][4]和arr[1][0])之间也是差4个字节,所以⼆维数组中的每个元素都是连续存放的。

4. sizeof 计算数组元素个数

sizeof是C语言中计算类型或者变量⼤⼩的关键字。因此我们可以用sizeof实现数组⼤⼩的计算。

c 复制代码
#include <stido.h> 

int main() 
{ 
 int arr[10] = {0}; 
printf("%d\n", sizeof(arr)); 
return 0; 
}

【输出】40

【计算出⼀个元素所占字节的个数】

c 复制代码
#include <stido.h> 
int main() 
{ 
 int arr[10] = {0}; 
 printf("%d\n", sizeof(arr[0]));//计算⼀个元素的⼤⼩,单位是字节 
 return 0; 
}

【计算数组的元素个数】

c 复制代码
#include <stido.h> 
int main() 
{ 
 int arr[10] = {0}; 
 int sz = sizeof(arr)/sizeof(arr[0]); 
 printf("%d\n", sz); 
 return 0; 
}

【输出】10

5. 变长数组

变长数组允许我们使用变量来指定数组大小

c 复制代码
int n = 0;
arr[n];

上述实例中,数组arr就是变长数组,因为它的长度取决于变量n的值,编译器没法实现确定,只有运行时才能够得知n是多少。

变长数组的根本特征是在运行时才可以确定数组的长度,所以变长数组不能初始化

【请公主王子们在gcc环境下测试以下代码】

c 复制代码
#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; 
}

6. 练习强化

6.1 练习

1. 实现多个字符从两端移动,向中间汇聚
2. 实现二分查找

【二分查找】在⼀个升序的数组中查找指定的数字n,很容易想到的⽅法就是遍历数组,但是这种⽅法效率⽐较低。⽐如我买了⼀双鞋,你好奇问我多少钱,我说不超过300元。你还是好奇,你想知道到底多少,我就让你猜,你会怎么猜?你会1,2,3,4...这样猜吗?显然很慢;⼀般你都会猜中间数字,⽐如:150,然后看⼤了还是⼩了,这就是⼆分查找,也叫折半查找。

6.2 答案

【解析1】

c 复制代码
#include <stdio.h>
int main()
{
        char arr1[] = "welcome to bit...";
        char arr2[] = "#################";
        int left = 0;
        int right = strlen(arr1)-1;
        printf("%s\n",arr2);
        while(left<=right)
        {
                Sleep(1000);
                arr2[left] = arr1[left];
                arr2[right] = arr1[right];
                left++;
                right--;
                printf("%s\n",arr2);
        }
        retutn 0;
}

【解析2】

c 复制代码
#include <stdio.h>
int main()
{
        int arr[] ={ 1,2,3,4,5,6,7,8,9,10 };
        int left = 0;
        int right = sizeof(arr)/sizeof(arr[0])-1;
        int key = 7;//要找的数字
        int mid = 0;//记录中间元素的下标
        int find = 0;
        while(left<=right)
        {
                mid = (left+right)/2;
                if(arr[mid]>key)
                {
                        right = mid-1;
                }
                else if(arr[mid] < key)
                {
                        left = mid+1;
                }
                else
                {
                        find = 1;
                        break;
                }
        }
        if(1 == find)
                printf("找到了,下标是%d\n",mid);
        else
                printf("找不到\n");
}

结语

以上就是小编对C语言数组的讲解。

如果觉得小编讲的还可以,还请一键三连!互三必回!

持续更新中~!

相关推荐
楼台的春风3 小时前
【GPIO详解及实践示例】
c语言·stm32·单片机·嵌入式硬件·mcu·物联网·嵌入式
ll7788114 小时前
LeetCode每日精进:20.有效的括号
c语言·开发语言·算法·leetcode·职场和发展
coding_rui7 小时前
链表(C语言版)
c语言·数据结构·链表
开开又心心的学嵌入式7 小时前
C语言——指针进阶应用
c语言·开发语言
coding_rui7 小时前
哈希表(C语言版)
c语言·数据结构·散列表
开开又心心的学嵌入式7 小时前
C语言——指针基础知识
c语言·开发语言
coding_rui7 小时前
二叉树(C语言版)
c语言·数据结构
aaasssdddd969 小时前
鸡兔同笼问题
c语言·线性代数·算法·矩阵·解释器
就爱学编程9 小时前
重生之我在异世界学编程之C语言:深入预处理篇(上)
c语言·开发语言
孤独得猿11 小时前
排序算法复习——包括插入排序、希尔排序、冒泡排序、快排(包括霍尔法、挖坑法、快慢指针法)、堆排、选择排序、归并排序等 (代码采用c/c++混编)
c语言·数据结构·c++·笔记·算法·排序算法