【保姆级讲解】C语言---数组精华

数组介绍

1.1数组概述

数组就是多个具有相同数据类型(char/int/long/float)的数值有序的集合在一起。根据存储的方式，又分为“一维数组”和“二维数组”；那根据存储的内容，又分为“数值数组”、“字符数组”以及“字符串数组”。

存储方式: “一维数组”“二维数组”

存储内容: “数值数组”“字符数组”“字符串数组”

1.2数组特点

1. 空间地址：数组的元素在存储器中是连续的(存储地址是连续的->存储空间是一整块)。
2. 访问数据：通过一个数组名，就可以访问数组中所有的元素。数组名+成员运算符即可访问buff[1]

注：当程序中出现了大量相同类型（含义）的数据时，就考虑是否使用数组。但在使用数组的时候，重点要关注数组中元素的个数（数组的长度），否则就会出现空间不足和空间浪费的问题。

后期最考察咱们的是:数组的空间容量分配是否合理;

空间不足:内存访问越界(单片机阶段尤为重要);

空间浪费:内存不足;

2.1数组应用

1. 1. 1. 一维数组应用
2. 一维数组概念

一维数组就是通常所说的数组。是指数组中存储的元素只有一个唯一的下标，我们称这样的数组为一维数组。

1. 一维数组定义

1. 数组定义格式：

数据类型 数组名[数组长度]   例：int a[12];  数据类型

• 数据类型：又叫元素类型，规定了数组中元素的类型。1个数组中所有的元素类型都是一致的;

数据类型有：基本数据类型、结构体数据类型、指针数据类型。

• 数组名： 数组的名称，自定义标识符(命名规则同变量:变量命名规则 可以为大小写英文字母、数组、美元$、下划线 数字不能开头 不能与关键字重名)。在同一个作用范围内，数组名跟变量不能重名。
• 数组长度： 规定了数组中元素的个数。数组长度必须是一个正整数的常量值。

1. 数组长度定义方法

• 未初始化赋值： 在定义数组时，没有给数组中的元素进行赋值(初始化赋值)，数组通过中括号[]的常量来确定数组的长度。

Int buff[10];长度为10  每个元素都为int类型，占有的连续的内存空间为10*4=40字节;

• 已初始化赋值：在定义数组的时候，没有通过中括号[]的常量来指定数组的长度，编译器会通过初始化赋值的元素个数来确定数组的长度。

Int buff[]={1,2,3,4,5,6};长度为根据{}内容确定6字节;

#include <stdio.h> int main() { int buff1[10]; int buff2[]={1,2,3,4,5,6,7,8,9}; printf("%u\n",sizeof(buff1)); //40字节 printf("%u\n",sizeof(buff2)); //36字节 //对于以上数组 //可用部分:buff1[]只能读写10个元素，每个元素为4字节 //可用部分:buff2[]只能读写9个元素空间，每个元素为4字节; return 0; }

1. 数组赋值方法

1. 初始化赋值
   1. 含义：在定义数组的同时，给数组中的元素进行赋值。
   2. 格式：数据类型 数组名[数组长度] = {元素1,元素2,……,元素n};

#include <stdio.h> int main() { //1）初始化赋值 //全部赋值 int buff1[5]={1,2,3,4,5}; //部分赋值 int  buff2[10]={1,2,3};  //未赋值的为0 int  buff3[10]={0};  //数组整体为0，每个元素空间都是0 return 0; }

注：在初始化赋值时，赋值中的数值和数组中排列的元素是一一对应的（从首元素开始），如果没有对数组中的所有元素进行赋值（只赋值了一部分元素），其他未赋值的元素默认值为0。并且数组的整体赋值只能在初始化的时候进行赋值，否则只能进行逐一赋值。

#include <stdio.h> int main() { //1）初始化赋值 //全部赋值 int buff1[5]={1,2,3,4,5}; //部分赋值 int  buff2[10]={1,2,3};  //未赋值的为0 int  buff3[10]={0};  //数组整体为0，每个元素空间都是0 //只能在初始化阶段进行赋值 全部赋值 部分赋值 //运算阶段不能进行整体赋值/部分(多个元素)赋值 buff1[5]={2,2,3,4,5}; return 0; }

例如：int x[10] = {1,2,3,4,5,6,7};  /*对数组的前7个元素进行了赋值，剩下的其他元素默认值为0 */

1. 逐一赋值
   1. 含义：在程序运行过程中，利用数组下标和赋值语句对数组中的某个元素进行赋值。数组下标从0开始到数组长度-1。

例如:

#include <stdio.h> int main() { //1）逐一赋值 int buff1[5]={1,2,3,4,5}; //在程序运行过程中，利用数组下标和赋值语句对数组中的某个元素进行赋值。数组下标从0开始到数组长度-1 buff1[1]=10; buff1[2] =30; buff1[3]=40; printf("%d\t%d\t%d\t%d\t%d\n",buff1[0],buff1[1],buff1[2],buff1[3],buff1[4]); return 0; }

注：在数组定义的时候，数组[]中的常量为数组长度，但是在数组应用的过程中，[]中的常量为数组的下标。在使用数组下标的时候，要注意不能越界。

#include <stdio.h> int main() { //1）逐一赋值 int buff1[5]={1,2,3,4,5}; //在程序运行过程中，利用数组下标和赋值语句对数组中的某个元素进行赋值。数组下标从0开始到数组长度-1 buff1[1]=10; buff1[2] =30; buff1[3]=40; printf("%s-%d\n",__FILE__,__LINE__); buff1[5]=0; printf("%s-%d\n",__FILE__,__LINE__); buff1[10]=100; printf("%s-%d\n",__FILE__,__LINE__); printf("%d\t%d\t%d\t%d\t%d\n",buff1[0],buff1[1],buff1[2],buff1[3],buff1[4]); return 0; }

例1：在键盘上输入任意10个自然数，求自然数之和

#include <stdio.h> int main() { //1在键盘上输入任意10个自然数，求自然数之和 unsigned int buff[10]={0};//基准 unsigned int sum =0; for(int i = 0;i < 10; i++) { printf("请输入%d个自然数\n",i+1); scanf("%d",&buff[i]); } for(int i = 0 ;i < 10 ; i++) { sum +=buff[i]; } printf("sum:%u\n",sum); return 0; }

1. 1. 1. 字符型数组应用
2. 字符型数组概述    
   1. 含义： 字符型数组本质上也是一个数组，是用来存放字符数据(char)的数组。
   2. 类型： 字符数组和字符串数组;(重点)

1. 字符数组

字符数组中的一个元素存放一个字符，字符数组的长度是数组中字符的个数。

char buff[]={‘A’,’B’,’C’}; 长度为3

1. 字符串数组

字符串数组是由字符数组加上字符串结束符’\0’来组成，一般使用双引号（””）来直接对数组进行赋值，字符串数组的长度为数组中字符的个数+1(‘\0’)。

串:多个字符组成 A\0   ASCII表中 ‘\0’ == 数值0

char  buff[]=”ABC”;长度为3+1（’\0’占一个字节的空间，但不算在字符串的有效长度之内）。字符串数组遇到’\0’就会结束字符串数组的读取。例：char x[] = “goo\0d”（/* 字符d将不会被保存到数组中 */），在写字符数组的时候写完了补上’\0’变成字符串数组。

#include <stdio.h> int main() { int i =0; //在写字符数组的时候写完了补上’\0’变成字符串数组。 char str1[]={'A','B','C','D'}; //字符数组 char str2[]={'E','F','C','D','\0'}; //字符数串组 printf("str1:%s\n",str1); printf("str2:%s\n",str2); while(str1[i++] != '\0') //虽然访问越界 但是通过该例子可以说明内存分配是连续的 { printf("%c",str1[i]); } return 0; }

#include <stdio.h> int main() { int i =0; //在写字符数组的时候写完了补上’\0’变成字符串数组。 char str1[]={'A','B','C','D'}; //字符数组 char str2[]={'E','F','C','D','\0'}; //字符数组转为字符数串组 char str3[]="ABCDEF"; //字符串数组(特殊的字符数组) printf("str1:%s\n",str1); printf("str2:%s\n",str2); printf("str3:%s\n",str3); while(str1[i++] != '\0') //虽然访问越界 但是通过该例子可以说明内存分配是连续的 { printf("%c",str1[i]); } return 0; }

字符串数组操作

对字符串数组的操作和其他数组操作一样，都是只能一个一个元素遍历操作，一般采用while循环来对字符串数据的循环读取（判断’\0’，从首元素开始读，一直读，读到’\0’为止）。例：while(x[i] != ‘\0’){i++}  

#include <stdio.h> int main() { int i =0; char str3[]="ABCDEF"; //字符串数组(特殊的字符数组) printf("str3:%s\n",str3); while(str3[i] != '\0') printf("%c",str3[i++]);  //while(str3[i] != '\0'){printf("%c",str3[i++]); } return 0; }

注：字符串不是一种数据类型，字符串必须要用数组或指针(区分)来存储。并且字符串数组允许以字符串的格式进行直接赋值（非初始化赋值），在使用字符串数组的时候，在考虑数组长度时，一定要考虑上’\0’，千万不要越界。/* 字符串可以用gets或者scanf(“%s”,变量名) 这种方式直接赋值----就是非初始化赋值 */

#include <stdio.h> int main() { int i =0; char str3[100]={0}; char str4[100]={0}; /**************************第一种字符串输入*************************************/ //需要的为地址 int A; 需要的为&A;数组首地址&str3[0],数组:数组名为数组的首地址 scanf("%s",&str3[0]); //scanf("%s",str3);等同scanf("%s",&str3[0]); printf("%s\n",&str3[0]); //printf("%s\n",str3);等同printf("%s\n",&str3[0]); //打印字符串时为什么要使用地址      一串数组/一个数据int double float printf()打印字符串时需要采用地址访问  访问单个数据时需要变量名 //注意:scanf以哪些情况作为结束标志:TAB键 空格 回车 三个符号 //scanf不会吸收： TAB键 空格 回车 三个符号 除scanf(“%c”)这种情况 //gets吸收了一个字符 换行 //措施 getchar(); //scanf不吸收TAB键 空格 回车 三个符号导致下列程序出错的解决措施 /**************************第二种字符串输入*************************************/ printf("请输入一串字符串\n"); gets(str4); printf("%s\n",str4); return 0; }

知识点回顾: #include <stdio.h> int main() { //TAB键  换行  空格 int inputNum1,inputNum2,inputNum3; scanf("%d%d%d",&inputNum1,&inputNum2,&inputNum3); printf("%d\t%d\t%d\n",inputNum1,inputNum2,inputNum3); return 0; }

字符串赋值不能直接=一个字符串常量,键盘输入字符串的时候可以直接赋值

#include <stdio.h> int main() { char buff[100]={0}; //buff="hello";不能整体赋值 //buff[0]="hello"; "hello"提供的是首地址  buff[0]存放的为一个字符 buff[0]="hello";//错误写法   不要犯 printf("%s\n",buff); return 0; }

1. 字符串数组输入

对字符串数组进行输入的时候，一般使用“输入字符串函数（gets()）”进行对字符串数组的输入。格式为：gets(数组名)。

练习： 在键盘上输入一个字符串，将字符串逆序输出

#include <stdio.h> int main() { int index = 0; char inputString[100]={0}; //在键盘上输入一个字符串，将字符串逆序输出 printf("请输入一串字符串\n"); gets(inputString); //逆序输出 计算串的有效长度 while(inputString[index] != '\0') { index++; } //inputString[index]=='\0';      //逆序输出 for(int at_i= index -1; at_i >=0 ;at_i--) { printf("%c",inputString[at_i]); } printf("\n"); return 0; }

Gets与scanf区别:

#include<stdio.h> #include<string.h> int main() { //2.输入一行字符，统计其中单词的个数，单词之间用空格分隔。 //首先分析scanf  gets区别 char inputstring[100]={0}; /******************************************************************** scanf("%s",inputstring); //只能捕获到空格、tab键、回车之前的 不包含这些字符 printf("%s\n",inputstring); **********************************************************************/ gets(inputstring); //只能回车之前的 可以包含TAB 空格这些字符 printf("%s\n",inputstring); return 0; }

1. 1. 1. 二维数组
2. 二维数组概述
   1. 含义： 又称为数组数组或者矩阵数组，是指元素都是数组的数组
   2. 格式：数据类型 数组名[数组行长度][数组列长度] = {{元素1,元素2,……,元素n},{元素1,元素2,……,元素n},{元素1,元素2,……,元素n}……};
   3. 示例：int x[3][4];/* 定义一个3行4列的二维数组 */

1. 二维数组赋值
   1. 二维数组赋值格式

数组赋值格式:

• • • 第一种(全赋值):int buff[3][4]={{1,2,3,4},{2,3,4,5},{3,4,5,6}};

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

• • • 第二种(全赋值 精简): int buff[3][4]={ 1,2,3,4, 2,3,4,5, 3,4,5,6};

#include <stdio.h> int main() { //② 第二种(全赋值 精简): int buff[3][4]={ 1,2,3,4, 2,3,4,5, 3,4,5,6}; int buff[3][4]={ 1,2,3,4, 2,3,4,5, 3,4,5,6}; for(int i = 0;i < 3; i++) { for(int j = 0; j < 4; j++) { printf("%d\t",buff[i][j]); } printf("\n"); } return 0; }

• • • 第三种(部分赋值): int buff[3][4]={ 1,2,3,4, 2,3,4,5};

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

• • • 第四种(不指定行长度): int buff[][4]= {{1,2,3,4},{5},{6,7,8,9}};

#include <stdio.h> int main() { //④ 第四种(不指定行长度): int buff[][4]= {{1,2,3,4},{5},{6,7,8,9}}; int buff[][4]= {{1,2,3,4},{5},{6,7,8,9}}; for(int i = 0;i < 3; i++) { for(int j = 0; j < 4; j++) { printf("%d\t",buff[i][j]); } printf("\n"); } return 0; }

• • • 第五种(不指定行长度): int buff[][4]={1,2,3,4,5,6,7,8,9};

#include <stdio.h> int main() { //⑤ 第五种(不指定行长度): int buff[][4]={1,2,3,4,5,6,7,8,9}; int buff[][4]={1,2,3,4,5,6,7,8,9}; for(int i = 0;i < 3; i++) { for(int j = 0; j < 4; j++) { printf("%d\t",buff[i][j]); } printf("\n"); } return 0; }

注：数组是按行连续存放，当数组初始化赋值时给出了数组中的全部元素，可以省略行长度（只能省略行长度，不能省略列长度），和省略数组中每行之间的大括号（{}）。

二维数组地址分配验证:

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

#include <stdio.h> int main() { //二维数组 存放整型数据--->字符串 char buff[3][10]={ "123456789", //== {'1','2','3','4','5','6','7','8','9','\0'} "abcdefgh", "110120119" }; //字符串每行首地址 printf("%s\n",&buff[0][0]); printf("%s\n",&buff[1][0]); printf("%s\n",&buff[2][0]); //只写行即为每行首地址 printf("%s\n",buff[0]); printf("%s\n",buff[1]); printf("%s\n",buff[2]); return 0; }

2.2冒泡算法

1. 1. 1. 冒泡算法概述

含义： 冒泡算法又称冒泡排序法，是将数组中的所有元素进行升序（由小到大）或降序（由大到小）的一种排序算法。

1. 1. 1. 冒泡算法原理

排序很重要:后期进行数据分析(单片机采集数据每个时刻进行采集),先进行排序,去掉差异值;

循环无序数列中的元素，把相邻的两个元素一一比较。同时在比较的过程中，一旦发生逆序排列（没有按照规定的排列顺序），就马上交换两个元素的位置。每趟将最值（最大值或最小值）沉底即可确定一个数在数列中的位置。

#include <stdio.h> int main() { int arrbuff[5]={14,25,62,15,10}; //冒泡排序 for(int i = 0 ; i < 5-1; i++) //趟数 { for(int j = 0; j < 5-1-i;j++)//对比次数 { int temp; if(arrbuff[j] > arrbuff[j+1]) //两个相邻数进行判断 { temp = arrbuff[j+1]; arrbuff[j+1] = arrbuff[j]; arrbuff[j] = temp; } } } //结果 for(int x = 0; x < 5;x++) { printf("%d\t",arrbuff[x]); } printf("\n"); return 0; }

1. 1. 课程回顾

数组:本质  里面的数据有什么特点:同种数据类型的数值的集合;

内存分配:一维数组/二维数组都是连续分配

一位数组: 数据类型 数组名[数组长度];

数组长度:直接赋值整数常量值 不能浮点型 赋值变量有点特殊;

数组长度:可以通过初始化赋值方式确定长度;

数组赋值:全部赋值 部分赋值(未 0)

逐一赋值 不能进行整体赋值;

输入赋值:scanf gets 区别

字符数组/字符串数组: \0

二维数组:[][]行可以省略但是对于列不能省略;

冒泡排序:数据排序->分析;

数组:2:30小时

14:00讲函数: 周三 上午讲讲作业  复习->期中考试