08-数组
数组
1.数组概述
在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。
数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。
- 数组中的每一个变量叫做元素,是数组的最小单位
- 数组的索引从0开始(上面的图片有错)
- 数组中的每个元素都是变量
数组属于构造数据类型：
- 一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。
- 构造类型:将基本类型构建成类型,数组:将相同类型的数据放在一个集合中,这种的构造类型--数组;结构体,存储不同的基础类型
int a[10];
struct Stu boy[10];
- 按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。
int a[10];
char s[10];
char *p[10];
通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。
2.一维数组
2.1 一维数组的定义和使用
- 数组名字符合标识符的书写规定(数字、英文字母、下划线)
- 数组名不能与其它变量名相同，同一作用域内是唯一的
- 方括号[]中常量表达式表示数组元素的个数
- 定义数组时[]内最好是常量，使用数组时[]内即可是常量，也可以是变量
- 数组的每个元素都是变量,可以被改变赋值
- 数组元素的初始值是随机的,
int a[3]表示数组a有3个元素
其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]
类型 数组名[数组元素个数]
#include <stdio.h>
int main()
{
int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
//a[0]…… a[9]，没有a[10]
//没有a这个变量，a是数组的名字，但不是变量名，它是常量
a[0] = 0;
//……
a[9] = 9;
int i = 0;
for (i = 0; i < 10; i++)
{
a[i] = i; //给数组赋值
}
//遍历数组，并输出每个成员的值
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
2.2 数组的初始化
在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。
- 数组定义时不初始化,所有元素的内容为随机值
- 数组定义时部分初始化,剩余所有的变量都是0
- 数组定义时不指明长度,定义的时候必须初始化,数组长度由{}内的元素个数决定
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
int a[10] = { 1, 2, 3 };//初始化前三个成员，后面所有元素都设置为0
int a[10] = { 0 };//所有的成员都设置为0
//[]中不定义元素个数，定义时必须初始化
int a[] = { 1, 2, 3, 4, 5 };//定义了一个数组，有5个成员
// 初始化第5个元素
int a[10] = {[5] = 5}; // 将第5个元素初始化,其他元素为0
2.3 数组的大小
#include <stdio.h>
int main()
{
int num[10] = {1,2,3,4,5,6,7,8,9.10};
printf("%d\n",sizeof(int [10])); // 返回数组元素的长度
printf("%d\n",sizeof(num)); // 返回数组的总长度
// 获取数组元素个数
int n = sizeof(num)/sizeof(num[0]); // 数组总长度/数组元素长度 = 数组元素个数
return 0;
}
2.4 数组在内存中的地址
启动一个程序的时候,系统会给程序分配一块内存空间,32位系统会分配4G的空间,内存的最小单位是字节,内存中的单位都是一个字节一个字节存储的,每个字节存储都有一个编号
- 内存的最小单位是字节
- 字节在内存中的编号就是内存地址
- 数据在内存存储的时候可能占据多个字节,数据在内存中的地址就是起始字节所在的地址
2.5 数组名
- 数组名是常量,不能被赋值
- &a -- 整个数组的地址
- &a[0] -- 数组第一个元素的地址
- a -- 数组第一个元素的地址
#include <stdio.h>
int main()
{
int a[5];
printf("%u\n",&a[0]);
printf("%u\n",&a);
printf("%u\n",a); // 这三个值在数值上是相等的
printf("%u\n",&a[0]+1); // 跨一个元素
printf("%u\n",&a+1); // 跨一个跨一个数组
printf("%u\n",a+1); // 跨一个元素
}
2.6 数组练习
2.6.1 数组最值
#include <stdio.h>
int main()
{
int a[] = { 1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
int i = 0;
int max = a[0];
for (i = 1; i < sizeof(a) / sizeof(a[0]); i++)
{
if (a[i] > max)
{
max = a[i];
}
}
printf("数组中最大值为：%d\n", max);
return 0;
}
2.6.2 数组逆置
#include <stdio.h>
int main()
{
int a[] = { 1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
int i = 0; // 初始指向0
int j = sizeof(a) / sizeof(a[0]) -1; // 初始指向数组最后的元素
int tmp; // 中间变量进行,数组元素交换
while (i < j)
{
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i++;
j--;
}
// 遍历数组的元素
for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
2.6.3 冒泡排序
- 相邻两个元素比较,大的放到后面,进行元素交换
- n个元素比较n-1轮
- 每轮的比较次数n-1-i(i是从0开始的轮数编号)
#include <stdio.h>
int main()
{
int a[] = { 1, -2, 3,- 4, 5, -6, 7, -8, -9, 10 };//定义一个数组，同时初始化所有成员变量
int i = 0;
int j = 0;
int n = sizeof(a) / sizeof(a[0]);
int tmp;
//1、流程
//2、试数
for (i = 0; i < n-1; i++)
{
for (j = 0; j < n - i -1 ; j++)//内循环的目的是比较相邻的元素，把大的放到后面
{
if (a[j] > a[j + 1])
{
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
for (i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
3.二维数组
3.1 二维数组的定义和使用
- 二维数组的a[0]表示第1行
二维数组定义的一般形式是：
类型说明符 数组名[常量表达式1][常量表达式2]
其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度
int a[3][4]
- 命名规则与一维数组相同
- 定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：
二维数组a是按行进行存放的，先存放a[0]行，再存放a[1]行、a[2]行，并且每行有四个元素，也是依次存放的。 - 二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。
- 在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的,也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。
- 二维数组的元素也是变量
遍历二维数组元素
#include <stdio.h>
int main(){
int a[3][4];
int n = sizeof(a)/sizeof(a[0]);
int l = sizeof(a[0])/sizeof(a[0][0]);
int i = 0;
int j = 0;
for(i = 0; i<n;i++){
for(j = 0;j<l;j++){
printf("%d\t",a[i][j]);
}
printf("\n");
}
return 0;
}
3.2 二维数组的初始化
#include <stdio.h>
int main()
{
// 二维数组定义
int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
// 使用单括号也可以,因为在内存中是单行排布的
int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
// 局部初始化,剩余元素全为0
int a[3][4] = {1,2,3};
// 二维数组不能省略列数,可以省略行数,自动根据列进行转换
int a[][4] = {1,2,3,4,5};
return 0;
}
3.2 二维数组大小
#include <stdio.h>
int main()
{
int a[3][4] = {1,2,3};
// 二维数组元素个数
int n = sizeof(a) / sizeof(a[0][0]);
// 二维数组行数
int l = sizeof(a) /sizeof(a[0]);
// 二维数组列数
int c = sizeof(a[0]) / sizeof(a[0][0]);
return 0;
}
3.4 二维数组的数组名
二维数组的数组名,也代表首行地址
- a[0][0]--表示第一行第一个元素
- &a[0][0]--表示第一行第一个元素的地址 - 01
- a[0]--代表第一行一维数组的数组名, a[0] = &a[0][0]
- a--二维数组的数组名,代表二维数组,也代表首行地址 &a[0]
- &a--二维数组的地址
&a[0][0]+1--元素地址加1跨过一个字节
a[0]--元素地址加1跨过一个字节
&a[0]+1--行地址加1跨过1行
a+1--行地址加1跨国1行
&a+1--二维数组地址加1跨过一个二维数组
#include <stdio.h>
int main()
{
int a[3][4];
printf("%u\n",&a[0][0]);
printf("%u\n",a[0]);
printf("%u\n",&a[0]);
printf("%u\n",a);
printf("%u\n",&a); // 打印出来在数值上相同
printf("%u\n",&a[0][0]+1); // +4 int 4字节
printf("%u\n",a[0]+1); // +4 int 4字节 跨一个元素
printf("%u\n",&a[0]+1); // +16 4*4 跨一行
printf("%u\n",a+1); // +16 4*4 跨一行
printf("%u\n",&a+1); // +48 跨一整个二维数组
return 0;
}
3.5 二维数组练习
#include <stdio.h>
int main()
{
//二维数组： 五行、三列
//行代表人： 老大到老五
//列代表科目：语、数、外
float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };
int i, j, person_low[3] = { 0 }; // person_low[]数组,统计各科不及格人数
float s = 0, lesson_aver[3] = { 0 }; // lesson_aver 统计各科平均分
for (i = 0; i < 3; i++) //三个科目
{
for (j = 0; j < 5; j++) // 每科目统计五次
{
s = s + a[j][i];
if (a[j][i] < 60)
{
person_low[i]++;
}
}
lesson_aver[i] = s / 5;
s = 0; // 成绩和,统计完之置0
}
printf("各科的平均成绩:\n");
for (i = 0; i < 3; i++)
{
printf("%.2f\n", lesson_aver[i]);
}
printf("各科不及格的人数:\n");
for (i = 0; i < 3; i++)
{
printf("%d\n", person_low[i]);
}
return 0;
}
4.多维数组
多维数组的定义与二维数组类似，其语法格式具体如下：
数组类型修饰符 数组名 [n1][n2]…[nn];
int a[3][4][5];
定义了一个三维数组，数组的名字是a，数组的长度为3，每个数组的元素又是一个二维数组，这个二维数组的长度是4，并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int。
#include <stdio.h>
int main()
{
//int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]
int a[3][4][5] = { { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } } };
int i, j, k;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
for (k = 0; k < 5; k++)
{
//添加访问元素代码
printf("%d, ", a[i][j][k]);
}
printf("\n");
}
}
return 0;
}
5.字符数组与字符串
5.1 字符数组与字符串的区别
- 字符数组存储的是字符,但是存储的是ascii码
- 字符串就是含有\0的字符数组
#include <stdio.h>
int main()
{
// 字符数组
char a[5] = {'a','b','c','d','e'};
// 带有\0的字符数组就是字符串
char a[5] = {'a','b','c','d','\0'};
// 字符串可以 用%s打印,遇到\0停止
// %s打印时要的是字符数组的首地址,首元素地址就是数组名
printf("%s\n",a);
char a[5] = "abcd"; //定义了一个字符数组,存的是abcd\0
char a[] = "world"; // 数组中有6个元素
char a[100] = "abcd"; // 数组中有100个元素
char a[100] = ""; // 将数组的第0个元素填0 其他元素就是\0
char a[100] = {0}; // 将一个字符数组清0
return 0;
}
- C语言中没有字符串这种数据类型，可以通过char的数组来替代；
- 字符串一定是一个char的数组，但char的数组未必是字符串；
- 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。
#include <stdio.h>
int main()
{
char c1[] = { 'c', ' ', 'p', 'r', 'o', 'g' }; //普通字符数组
printf("c1 = %s\n", c1); //乱码，因为没有’\0’结束符
//以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
char c2[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0'};
printf("c2 = %s\n", c2);
//字符串处理以‘\0’(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
char c3[] = { 'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
printf("c3 = %s\n", c3);
return 0;
}
5.2 字符数组的初始化
#include <stdio.h>
int main()
{
char a[128] = "abcd\0def\0";
printf("%s\n",a); // abcd
printf("%d\n",sizeof(a)); // 128
char b[] = {'a','b','c'};
printf("%s\n",b); // 乱码,没有\0作为结束符会读到其他地址上
system("pause");
return 0;
}
#include <stdio.h>
// C语言没有字符串类型，通过字符数组模拟
// C语言字符串，以字符‘\0’, 数字0
int main()
{
//不指定长度, 没有0结束符，有多少个元素就有多长
char buf[] = { 'a', 'b', 'c' };
printf("buf = %s\n", buf); //乱码
//指定长度，后面没有赋值的元素，自动补0
char buf2[100] = { 'a', 'b', 'c' };
char buf[1000]={“hello”};
printf("buf2 = %s\n", buf2);
//所有元素赋值为0
char buf3[100] = { 0 };
//char buf4[2] = { '1', '2', '3' };//数组越界
char buf5[50] = { '1', 'a', 'b', '0', '7' };
printf("buf5 = %s\n", buf5); // 1ab07乱码
char buf6[50] = { '1', 'a', 'b', 0, '7' };
printf("buf6 = %s\n", buf6); // 1ab
char buf7[50] = { '1', 'a', 'b', '\0', '7' };
printf("buf7 = %s\n", buf7); // 1ab
//使用字符串初始化，编译器自动在后面补0，常用
char buf8[] = "agjdslgjlsdjg";
//'\0'后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
//'\ddd'八进制字义字符，'\xdd'十六进制转移字符
// \012相当于\n
char str[] = "\012abc";
printf("str == %s\n", str);
return 0;
}
5.3 字符串的输入输出
5.3.1 scanf()
- 字符串存在字符数组中
#include <stdio.h>
int main()
{
char num[128] = ""
scanf("%s",num); // num就是字符数组首元素的地址
printf("[%s]\n",num);
char str[100];
printf("input string1 : \n");
scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
printf("output:%s\n", str);
return 0;
}
- scanf("%s",num)- 遇到空格结束,遇到\n也结束,也就是说中间输入不能有空格
- scanf()输入字符串超过定义的字符数组的长度,如果定义字符数组5个字节,但是输入了10个字节,会一直将5个字节之后的5个字节继续写入字符,会造成内存污染
5.3.2 gets()
- 从键盘上读取字符串
- 可以读取空格
- gets()也会造成内存污染
#include <stdio.h>
char *gets(char *s);
功能：从标准输入读入字符，并保存到s指定的内存空间，直到出现换行符或读到文件结尾为止。
参数：
s：字符串首地址
返回值：
成功：读入的字符串
失败：NULL
#include <stdio.h>
int main()
{
char num[128] = "";
// 遇到\n结束,但是可以读取空格
gets(num); // ()里面参数是要存放读取字符串的地址
printf("%s\n",num);
printf("pause");
return 0;
}
注意：由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。
5.3.3 fgets()
- 从键盘读取一个字符串
- 第一个参数是字符数组首地址
- 第二个参数是最大可以读取多少个
- 第三个参数是从哪里读取,键盘--stdin
#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
功能：从stream指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 '\0' 作为字符串结束。
参数：
s：字符串
size：指定最大读取字符串的长度（size - 1）
stream：文件指针，如果读键盘输入的字符串，固定写为stdin
返回值：
成功：成功读取的字符串
读到文件尾或出错： NULL
#include <stdio.h>
int main()
{
char buf[128] = "";
fgets(buf,sizeof(buf),stdin); // 最多读127个,会自动补\0
printf("%s\n",buf); // 输入hello 输出 hell
// fgets()会将回车进行读取
// 不想读取\n?
return 0;
}
5.3.4 strlen()
- #include <string.h>
- strlen()测字符数组有效字符的个数
- strlen()要的是字符数组的首元素地址
#include <stdio.h>
int main()
{
char buf[128] = "helloA";
// 不想读取\n? -- 将\n位置置为0 -- 要找到\n的位置
// 找到最后\n的下标
// 将buf[5]=0
// 求的是字符数组的有效个数
int i = 0;
while(buf[i]!='0')
{
i++
}
printf("i = %d\n",i); // 6
buf[i-1] = "\0";
printf("%s\n",buf); // hello 不是 helloA
i = strlen(buf); // 6 strlen()测字符数组有效字符的个数
system("pause");
return 0;
}
将fgets()函数读到的\n置为0,%s输出的时候就没有换行了
#include <stdio.h>
#include <string.h>
int main()
{
char buf[1024] = "";
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf)-1] = 0;
printf("%s\n",buf);
system("pause");
return 0;
}
5.3.5 puts() 和 fputs()
- puts()要的是数组元素地址,有换行
- f(buf,stdout),第一个参数,数组首元素地址,stdout标准输出(屏幕)
#include <stdio.h>
int puts(const char *s);
功能：标准设备输出s字符串，在输出完成后自动输出一个'\n'。
参数：
s：字符串首地址
返回值：
成功：非负数
失败：-1
#include <stdio.h>
int main()
{
printf("hello world");
puts("hello world");
return 0;
}
#include <stdio.h>
int fputs(const char * str, FILE * stream);
功能：将str所指定的字符串写入到stream指定的文件中， 字符串结束符 '\0' 不写入文件。
参数：
str：字符串
stream：文件指针，如果把字符串输出到屏幕，固定写为stdout
返回值：
成功：0
失败：-1
5.3.6 字符串追加
#include <stdio.h>
int main()
{
char str1[] = "abcdef";
char str2[] = "123456";
char dst[100];
int i = 0;
while (str1[i] != 0)
{
dst[i] = str1[i];
i++;
}
int j = 0;
while (str2[j] != 0)
{
dst[i + j] = str2[j];
j++;
}
dst[i + j] = 0; //字符串结束符
printf("dst = %s\n", dst);
return 0;
}
5.4 产生随机数
- 先产生随机数种子
- 再产生随机数
int main()
{
// 设置随机数种子
// 获得随机数
srand(10);
int a = rand(); //rand()获得随机数
printf("a = %d\n",a);
int b = rand();
printf("b = %d\n",b);
system("pause");
return 0;
}
- 随机数每次产生随机数种子都是10,两次之间会产生一样的数据,想要让产生的随机数不同,可以将当前的时间作为随机数种子传入
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
int main()
{
// 设置随机数种子
// 获得随机数
//int t = time(NULL); // time函数获得当前的时间,s
//srand(t);
srand(time(NULL)); // 设置随机数种子
int a = rand(); //rand()获得随机数
printf("a = %d\n",a);
int b = rand();
printf("b = %d\n",b);
system("pause");
return 0;
}
想要固定位数的随机数,可以取多个随机数中的一位,拼成多位随机数
