C语言学习阶段性总结（2）

四.数组

使用场景

1.一个班级里面有20个学生

2.一个机房里面有40台电脑

一.数组基本情况

1.数组类型定义

2.在一个数组中，每个元素没有变量名

3.数组定义格式：类型符 数组名[常量表达式] 例如：int array[10];

4.数组初始化方法：

1）方式1：int array[5]={5,8,13,17,19}-定义元素确定的整数型数组，元素分别为5,8,13,17,19，这是数组的完全初始化。

int array[8]={10,20,30,40,50,60,70,80};

2）方式2：int array[5]={6,8}-定义元素确定的整数型数组，元素分别为5,8,剩下的部分是由0代替，这是数组的不完全初始化。

int array[8]={10,20,30,40};

3）方式3：int array[5]={}-定义元素确定的整数型数组，全部都是由0代替，这是数组的完全不初始化。

int array[8]={};

4）方式4：对于已经确定的元素的数组，因此可以不指定数组长度。

int array[]={10,20,30,40,50,60,70,80};

5.数组的遍历：通过下标进行访问，结合循环语句进行访问

#include  <stdio.h>
int main()
{
	int arr[10];
	int data;      //定义数组的元素编号
	for(data=0;data<10;data++)
	{
		arr[data] = data + 15;
		printf("%d ",arr[data]);
	}
	printf("数组初始化完毕\n");
	return  0;
}

通过对data赋予不同的初始值来设定访问数组的开始元素编号

例如：将data初始值设定为3，那么就是从第3号元素arr[2]开始访问。

#include  <stdio.h>
int main()
{
	int arr[10];
	int data;      //定义数组的元素编号
	for(data=2;data<10;)
	{
		arr[data] = data + 15;
		printf("%x ",&arr[data]);
		printf("%d \n",arr[data]);
		data = data + 1;
	}
	printf("数组初始化完毕\n");
	return  0;
}

 

 练习：初始化数组以及大小计算

#include  <stdio.h>
int main()
{
	int size;
	int data;    //定义数组的元素编号
	int a[]={20,12,55,41,66,22,955,8,65,99,100,101};
	int arr[10];
	size = sizeof(a)/sizeof(a[2]);
	printf("数组大小为： %d\n",size);
	for(data=0;data<10;)
	{
		arr[data] = data + 15;   //数组的第一个元素初始化为15
		printf("%x ",&arr[data]);
		printf("%d \n",arr[data]);
		data = data + 1;
	}
	printf("数组初始化完毕\n");
}

二.一维数组编程练习

1.冒泡排序法

1）基本方法

2）算法步骤

step1：每次比较相邻的两个元素。

step2：如果比较过程中，如果顺序错误，那么就将两个数据交换，将较大的数放在后面。 

3）过程演示：模拟数组[6,4,7,1,2]

第一轮：得到整个数组中最大的，并将他放在最后面（从前到后全部比较）

        第一轮第一次：4,6,7,1,2（4小于6，将6放在后面）

        第一轮第二次：4,6,7,1,2（满足条件，不用交换）

        第二轮第三次：4,6,1,7,2（1小于7，将7放在后面）

        第一轮第四次：4,6,1,2,7（2小于7，将7放在后面）

第二轮：去除已知整租数组的最大值7，将剩余的数再次进行排列，得到剩下的数据中的最大值

        第二轮第一次：4,6,1,2,7（满足条件，不用交换）

        第二轮第二次：4,1,6,2,7（1小于6，将6放在后面）

        第二轮第三次：4,1,2,6,7（2小于6，将6放在后面）

第三轮：去除已经知道的两个最大的数据，将剩余的数据继续进行排列，得到剩下的数据中的最大值

        第三轮第一次：1,4,2,6,7（1小于4，将4放在后面）

        第三轮第二次：1,2,4,6,7（2小于4，将4放在后面）

到此，比较全部结束，得到从小到的排序是：1,2,4,6,7

总结

对于有n个数的数组，需要进行n-1轮的比较，每一轮进行n-1-i次比较，其中i表示比较的实际轮数

#include <stdio.h>
main()
{
    int i;   //定义比较的轮数
    int j;   //定义每轮比较的次数
    int len; //定义数组长度
    int data;//交换数据的临时变量
    int array[] = {6,4,7,1,2};
    len = sizeof(array)/sizeof(array[0]);
    for(i=0;i<len-1;i++)
        {
        for(j=0;j<len-1-i;j++)  //随着轮数的不断增加，每轮比较的次数也会发生改变，改变方式是len-1-i
           {
            if(array[j]>array[j+1])
               {
                    data = array[i];
                    array[i] = array[i+1];
                    array[i+1] = data;
               }
            }
        }
}

2.简单排序法

1）基本方法

 2）算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

3）过程演示：模拟数组[2,3,4,5,1]

第一轮：找到整个数组中最小的元素，将他放在第一位

        第一轮第一次：2,3,5,4,1（满足条件，不用交换）

        第一次第二轮：2,3,5,4,1（满足条件，不用交换）

        第一轮第三次：2,3,5,4,1（满足条件，不用交换）

        第一轮第四次：1,3,5,4,2（2大于1，将1与2位置调换）

第二轮：去除第一次比较之后的结果，找到第二大的元素，将他放在第二位

        第二轮第一次：1,3,5,4,2（满足条件，不用交换）

        第二轮第二次：1,3,5,4,2（满足条件，不用交换）

        第二轮第三次：1,2,5,4,3（3大于2，将2和3位置调换）

第三轮：去除前两轮比较之后的结果，找到第三大的元素，将他放在第三位

        第三轮第一次：1,2,4,5,3（5大于4，将5和4位置交换）

        第三轮第二次：1,2,3,5,4（4大于3，将4和3位置调换）

第四轮：去除前三轮比较之后的结果，找到第四大的元素，将他放在第四位

        第四轮第一次：1,2,3,4,5（5大于4，将5和4位置交换）

总结 ：

对于n个元素的数组，需要比较n-1轮，每轮需要比较n次，每次都是从后面的一位开始

#include  <stdio.h>
int main()
{
	int array[12,8,6,47,3,5,44]
	int i;
	int j;
	int len;
	int data;
	len = sizeof(array)/sizeof(array[0]);
	for(i=0;i<len-1;i++)
	{
		for(j=i+1;j<len;j++)
		{
			if(array[i]>array[j])
			{
				data = array[i];
				arrray[i] = array[j];
				array[j] = data;
			}
		}
	}
}

由于是存在有轮数与比较次数的关系，因此在进行if判断的时候，需要写出i与j之间的关系。

三.二维数组

1.二维数组使用条件

比如，某公司有3个团队，每个团队有5名员工，要将这些员工的工资数据进行保存，那么就要进行二维数组，需要建立一个二维数组，一维用来表示第几团队，二维用来表示每个团队的每个员工

	员工编号
团队编号	A1	A2	A3	A4	A5
	B1	B2	B3	B4	B5
	C1	C2	C3	C4	C5

例如可以用pay2,3表示B3员工的工资数。

2.如何定义一个二维数组

规则：

定义形式：类型说明符 数组名[常量表达式][常量表达式]

例如： float a [3][4];

定义一个名为a的3*4列数组。

解释：

在C语言中，对于二位数组可以被看做是一种特殊的一维数组，他的元素又是一个一维数组，在a[3][4]这样的一个二维数组中，他有三个元素，分别是a[0]，a[1]，a[2]，而每一个元素中都包含的有4个不同的元素，因此可以将这样的二维数组进行如下的方便书写。

a[0]：父级元素1	a[0][0]	a[0][1]	a[0][2]	a[0][3]
a[1]：父级元素2	a[1][0]	a[1][1]	a[1][2]	a[1][3]
a[2]：父级元素3	a[2][0]	a[2][1]	a[2][2]	a[2][3]

3.二维数组初始化

按行列初始化

int a[3][4] = {{1,2,3,4},{5,6,7,8,},{9,10,11,12}};

这种赋予初值的方法比较直观，将第一个花括号内的数据给第一行的元素，第二个画括号的数据赋值给第二行元素，……就是按照行进行赋值

没有明确行列，类似于一维数组

int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

这种方法和以一种相比，第一种方法一行对一行，界限清楚，第二种方法如果数据过多，那么就会写成一大片，容易遗漏，也不好检查

部分赋初值

对于各行中的某一元素赋予初值,例如：

int a[3][4] = {{1},{0,8},{2,6,9}}

初始化之后的元素如下：

1	0	0	0
0	8	0	0
2	6	9	0

对于某几行赋予初值，例如

int a[3][4] = {{1},,{2,6,9}}

初始化之后的元素如下：

1	0	0	0
0	0	0	0
2	6	9	0

只对每一行的第一列的元素赋予初值，例如：

int a[3][4] = {{1},{4},{2}}

初始化之后的匀速如下

1	0	0	0
4	0	0	0
2	0	0	0

注意：

对于二维数组而言，可以对一维长度不用定义，也就是行号，但是对于二位长度不能省略。例如：

int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

等价于下面的定义

int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

二维数组遍历

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

}