冒泡、选择排序；二维数组；函数三要素，形参实参

冒泡排序法

第一轮从前往后两两比较，4个元素比较3次，得出最大值为13。

第二轮，3个元素比较2次，最大值为12。

第三轮，2个元素比较1次，最大值为9。

通过简单较少的数据推导得出结论，i个元素需要比较i-1轮，第j轮需要比较i-1-j次。

#include <stdio.h>
/*
冒泡排序法:
假设有一个数组array[ ]={12,8,13,9};
对其中元素进行排序并分别正逆序输出。
*/

int main()
{
	int array[]={12,8,13,9};
	int i;
	int j;
	int len;
	int tmp;

	len = sizeof(array)/sizeof(array[0]);

	for(i=0;i<len-1;i++){
		for(j=0;j<len-1-i;j++){
			if(array[j]>array[j+1]){//如果大于就交换
				tmp=array[j];
				array[j]=array[j+1];
				array[j+1]=tmp;
			}
		}
	}
	puts("从小到大打印:");
	for(i=0;i<=len-1;i++){
		printf("%d,",array[i]);
	}
	puts("\n从大到小打印:");
	for(i=len-1;i>=0;i--){
		printf("%d,",array[i]);
	}
	
	return 0;
}

自己输入数据

#include <stdio.h>
/*
冒泡排序法:
自己输入一个数组。
对其中元素进行排序并分别正逆序输出。
*/
int main()
{
	int i;
	int j;
	int tmp;
	
	int len;
	printf("请输入数组元素个数：\n");
	scanf("%d",&len);
	int array[len];
	
	puts("请输入数组元素：");
	for(i=0;i<len;i++){
		scanf("%d",&array[i]);
	}
	//len = sizeof(array)/sizeof(array[0]);

	for(i=0;i<len-1;i++){
		for(j=0;j<len-1-i;j++){
			if(array[j]>array[j+1]){//如果大于就交换
				tmp=array[j];
				array[j]=array[j+1];
				array[j+1]=tmp;
			}
		}
	}
	puts("从小到大打印");
	for(i=0;i<=len-1;i++){
		printf("%d,",array[i]);
	}
	puts("\n从大到小打印");
	for(i=len-1;i>=0;i--){
		printf("%d,",array[i]);
	}
	
	return 0;
}

简单排序法

#include <stdio.h>
/*
简单排序法
依次比较，把最大的放在前面
*/

int main()
{
	int i;
	int j;
	int tmp;
	int len ;
	int array[]={8,12,13,9};
	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]){
				tmp=array[i];
				array[i]=array[j];
				array[j]=tmp;
			}
		}
	}
	printf("从大到小为：");
	for(i=0;i<len;i++){
		printf("%d ",array[i]);
	}
	return 0;
}

二维数组

#include <stdio.h>
/*
二维数组  array[i][j]:一个i行j列的二维数组
*/

int main()
{
	int array[2][3]={111,222,333,444,555,666};
	int array1[2][3]={{111,222,333},{444,555,666}};
	
	for(int i=0;i<2;i++){
		for(int j=0;j<3;j++){
			printf("%p %d ",&array[i][j],array[i][j]);
		}
		putchar('\n');
	}

	return 0;
}

二维数组初始化

可以对二维数组中的某几个元素赋值，其他的元素默认为0。

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

如果对全部元素都赋初值（即提供全部初始数据），则定义数组时对第1维的长度可以不指定，但第2维的长度不能省略。

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>
/*
有一个3*4的矩阵，要求编程求出其中最大的那个元素值，
以及其所在的行号和列号。
*/

int main()
{
	int a[3][4]={1,0,4,8,6,9,12,7,9,10,11,3};
	int i;
	int j;
	int hang;
	int lie;
	int max;
	max = a[0][0];  
	for(i=0;i<3;i++){
		for(j=0;j<4;j++){
			if(max < a[i][j]){
				max = a[i][j];
				hang = i+1;
				lie = j+1;
			}
		}
	}
	printf("最大值为：%d\n行号：%d\n列号：%d",max,hang,lie);
	
	return 0;
}

为什么要用函数：

1. 避免代码冗长。
2. 模块化设计思路。
3. 按功能划分，每个函数代表一个功能，而函数的名字要体现函数的功能含义，类似变量标识符y=f(x)。

函数要先定义再使用，和变量一个道理。

函数三要素：

1. 函数名：体现功能。
2. 参数列表：比如z=f(x,y)中x，y就是参数，参数的个数根据需求定义。
3. 返回值：比如y=f(x)，y是函数根据x的值和f的功能执行后的结果。

形式参数和实际参数

1. 定义函数时，函数名后面的括号中的变量名是“形式参数”；调用函数时，函数名后面括号中的参数是“实际参数”，实际参数可以是常量、变量或表达式。
2. 传递参数，传递的是值。即形参和实参的值相同，但是地址空间不同。
3. 函数中定义的变量是局部变量，存在生命周期：被存放在栈空间，函数被调用的时候才为局部变量申请内存，函数调用结束内存空间被系统释放。