C语言——数组

一：C语言——数组

一：一维数组

一：一维数组的定义

    定义：一组数，一组相同类型元素的集合。（是同类型变量的集合，共用一个名字用下标区分）

              其中每一个变量称作数组元素

注：一维数组对应数学中的数列，二维数组对应矩阵

语法结构（定义）：元素类型+arrname数组名[数组大小(一定是常量表达式）]尤其const修饰的常变量

是一个误区

（只有c99的语言标准才支持放变量）按照下标顺序在内存中存放

注：一维数组与数学中的数列对应，二维数组与矩阵对应

一维数组的定义：格式：类型说明符 数组名字[常量表达式]；（常量表达式不能进行动态定义即大于0的

正整数）数组名就是数组，数组名[常量表达式]为数组元素等价于普通变量

例：int arr a[8];

char arr b[8];

注意：数组必须先定义后使用

数组元素表达形式，数组名[下标]下标从0开始

只能单独应用数组元素，不能一次性引用整个数组

下标只能是整型常量或者整型表达式，数组元素在功能是等价于一个普通的变量

一维数组的初始化：（数组不初始化，其元素值为随机数）

1：完全初始化：int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

2：不完全初始化 int arr[10] = { 1,2,3,4,5 };只有前五个有赋值

当[]里面不写数字下面两个等效

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

int arr[5] = { 1,2,3,4,5 };根据初始化确定个数（编译器根据初值个数确定数组长度）

也可以对部分数组元素进行初始化：int arr[6] = { 1,2,3,4,5 };

字符数组初始化；

字符数组的输入输出：逐个字符%c,整个字符串%s 数组名表示首元素地址前面不可以加&输入串函数小于

数组长度遇到空格回车自动结束

其中arr与&arr[0]等价

char ch[5] = { 'a','b','c' };单引号一个一个往进去放\0没有\0程序就不能停止下来是乱码

char ch[] = { 'a','b','c' };此时[]只有3

第二种写法char ch[] = "abc";相当于a,b,c,\0相当于后面可以确定前面的

两种写法的区别char ch[5]={} char ch[] = ""第一个打印出来有随机值

用{}的时候需要以\0结尾 ""他内部自己就有\0

一维数组的使用：

         数组[]下标引用操作符数组通过下标开始访问，默认从0开始

代码部分：

#include<stdio.h>（一次性输入）
int main()
{
int i = 0;
int a[10] ;
printf("输入10个数字");
scanf_s("%s", a);一次性输入数组的时候数组名就是地址所以只要写数组名就行了此时是数
组名
for (i = 0; i <= 9; i++)
printf("%d\n", a[i]);
}
#include<stdio.h>（单个单个输入）
int main()
{
int i = 0;
int a[3] = { 0 };
for(i=0;i<3;i++)
{
scanf("%d",&a[i]);此时输入的是整型此时a[i]相当于一个普通变量
}
for(i=0;i<3;i++)
{
printf("%d",a[i]);
}
}

 冒泡排序法（把两个相邻数比较，小的调到前面）

#include<stdio.h>void Bubble_sort(int arr[], int size)
{
int j,i,tem;
for (i = 0; i < size-1;i ++)//size-1是因为不用与自己比较，所以比的数就少一个
{
int count = 0;
for (j = 0; j < size-1 - i; j++) //size-1-i是因为每一趟就会少一个数比较
{
if (arr[j] > arr[j+1])//这是升序排法，前一个数和后一个数比较，如果前数大则
与后一个数换位置
{
tem = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tem;
count = 1;
}
}
if (count == 0) //如果某一趟没有交换位置，则说明已经排好序，直接退
出循环
break;
}
}

int main()
{
int arr[10];
int i;
printf("请输入10个数\n");
for (i = 0; i < 10; i++) //接收用户的数值
{
scanf("%d", &arr[i]);
}
printf("排序前的数组>");
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
printf("\n排序后的数组>");
Bubble_sort(arr, 10);
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

用数组求fibonaccci数列的前二十个数字

#include<stdio.h>
int main()
{
int i=0;
int a[20]={1,1};
for(i=2;i<=20;i++)
{
a[i]=a[i-1]+a[i-2];
}
printf("%s",a);}
一维数组在内存中的存储：
%p以地址的形式打印十六进制打印
int main()
{
int arr[10] = { 0 };
int i = 0;
for (i = 0; i < 10; i++)
{
printf("&arr[%d}=%p\n", i, &arr[i]);
}
}

三：一维数组总结

结论：一维数组在内存中是连续存放的，随着下标的增长，地址是由低到高变化的

数组名是首元素地址

四：一维数组应用

//一维数组
#include<string.h>
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
arr[4] = 7;
char ch1[] = { 'a','b','c' };
int i = 0;
char ch2[] = "abc";
printf("%s\n", ch1);
printf("%s\n", ch2);
printf("%d\n", strlen(ch1));
printf("%d\n", strlen(ch2));
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
}

二：二维数组 

C语言有行有列等价于数学里面的矩阵(C语言中允许定义多维数组三维乃至n维）

一：二维数组定义

   定义：类型+数组名[常量表达式1][常量表达式2](二维数组是由行个一维数组组成的）

例子： int arr[3][4];

int a[0][0]	int a[0][1]	int a[0][2]	int a[0][3]
int a[1][0]	int a[1][1]	int a[1][2]	int a[1][3]
int a[2][0]	int a[2][1]	int a[2][2]	int a[2][3]

二：二维数组的初始化

初始化：初始化即创建的同时给他赋值

相当于放满不完全初始化-后面补零

部分初始化：int a[3][3]={{1},{0,1},{0,0,1}};相当于矩阵

1	0	0
0	1	0
0	0	1

第一种写法：int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12,};

第二种办法int arr[3][4] = {{1,2,3,4}，{5,6,7,8}，{9,10,11,12}};

1	2	3	4
5	6	7	8
9	10	11	12

重点注意：行可以省略但是列不可以

三： 二维数组的使用：

  1.行号从0开始，列号也从0开始和一位数组类似 打印一个二维数组的所有数

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

  2.二维数组在数组中的存储

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

三：二维数组总结

1.二维数组在内存中也是连续存在的，一行是连续的，跨行也是连续的

2.数组作为函数参数

3.数组传参其实传的是首元素的地址，传过去的不可以计算大小

4.数组名是首元素的地址

（有两个例外， 一个是sizeof内部放一个表示整个数组的大小单位是字节）

2，取地址数组名此时数组名表示整个数组）

经典程序：冒泡算法

思想是两两相邻元素进行比较并且可能需要交换（指针可以传地址）

#include<stdio.h>
void bubble_sort(int arr[], int x)//本质是指针，一个指针变量的的大小是4个字节
{
int i = 0;//趟数
for (i = 0; i < x - 1; i++)
{ // 一趟冒泡排序的过程
int j = 0;
for (j = 0; j < x - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int tem = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tem;
}
}
}
}

四：二维数组应用

求二维数组中最大的元素值及其行列号

#include <stdio.h>
void main()
{
int a[3][4] = { {1,2,3,4},{9,8,7,6},
{-10,10,-5,2} };
int i, j, row = 0, colum = 0, max;
max = a[0][0];随时随刻更新着max的值
for (i = 0; i <= 2; i++)
for (j = 0; j <= 3; j++)
if (a[i][j] > max)
{
max = a[i][j]; row = i; colum = j;
}
printf("max=%d,row=%d, \ colum=%d\n", max, row, colum);
将一个二维数组中的行列互换
#include<stdio.h>
void main()
{
int a[2][3] = { {1,2,3},{4,5,6} };
int b[3][2], i, j;
printf("array a : \n");
for (i = 0; i <= 1; i++)
{
for (j = 0; j <= 2; j++)
{
printf(" % 5d", a[i][j]);
b[j][i] = a[i][j];
}
printf("\n");
}
printf("array b : \n");
for (i = 0; i <= 2; i++)
{
for (j = 0; j <= 1; j++)
printf(" % 5d", b[i][j]);
printf("\n");
}
}

二：常用的字符串处理函数

 必须引用下面这个头文件

#include<string.h>

​
1：字符串输入函数 gets 格式 gets（字符串数组名）从键盘输入以回车结束的字符串自动加\0
注：输入串长度小于字符串长度
#include<string.h>

2：字符串输出函数 puts 格式 puts（字符串数组名）向显示器输出字符串（输出完自动换行）注：字符数组必须以‘\0’结束
3:字符串连接函数strcat格式：strcat(字符数组1,字符数组2)
功能：把字符数组2连到字符数组1后面
返值：返回字符数组1的首地址
说明：字符数组1必须足够大
连接前,两串均以‘\0’结束;连接后,串1的‘\0’取消, 新串最后加‘\0’
4：字符串拷贝函数strcpy格式：strcpy(字符数组1,字符串2)
功能：将字符串2，拷贝到字符数组1中去
返值：返回字符数组1的首地址
说明：字符数组1必须足够大，拷贝时‘\0’一同拷贝，不能使用赋值语句为一个字符数组赋值 :
5：字符串长度函数strlen格式：strlen(字符数组)
功能：计算字符串长度 返值：返回字符串实际长度，不包括‘\0’在内
​