C语言学习笔记：17_数组-一维数组（基本操作，取舍和冒泡排序，斐波那契数列）
C语言学习笔记：17_数组-一维数组（基本操作，选择和冒泡排序，斐波那契数列）
/*
* 17_数组-一维数组.c
*
* Created on: 2015年7月6日
* Author: zhong
*/
#include <stdio.h>
#include <stdlib.h>
/**
* 数组是一组有序数据的集合，在内存中是连续，顺序存储的。
*
* 1: 定义 一个数组：
* 类型 数组名[数组长度];
* int array[10]; //定义一个有10个元素的整型数组
* //由于数组在内存中是连续的内存空间，所以在定义数组时要指定数组的长度，以便开辟内存块以之使用。
* 注意： 数组的下标是从0开始的，长度为10的数组，有效下标为0-9
* 在c语言中，访问超过数组长度的下标元素也不会报错，只是访问了内存中不确定数组。
* 不像在java里面，如果访问下标超过了数组有效下标（长度-1） 就会报数组角标越界的异常
*
* 定义数组并初始化：
* 为了方便使用，在定义数组的同时，可以给数组初始化。
*
* int a[10]; //如果不对数组进行初始化就访问数组的元素，哪么获得的值是不确定的
*
* int a[10]={0,1,2,3,4,5,6,7,8,9}; //定义时给数组全部元素初始化
*
* int a[10]={0,1,2,3}; //也可以只给某些数组初始化，没指定值的元素被初始化为0
*
* int a[10]={0}; //给数组元素全部初始化为0
* int array[10]={};//给数组元素全部初始化为0
*
* int a[]={0,1,2,3,4,5,6,7,8,9}; //当对所有元素赋初值后，可以不用显式指定数组的长度，系统会根据元素个数计算数组长度
*
* 在定义数组时，指定了数组的长度并对初始化，凡没被“初始化的元素”，系统会自动把它们初始化为0;（如果是字符型数组，则初始化为'\0'）
* 如果是指针型数组，则初始化为NULL，即空指针）
*
* 引用一维数组元素：
* 在定义数组并对其中各元素赋值后，就可以引用数组中的元素了。
* array[0]; //引用数组下标为0的元素
*
* 内存存储情况：
* int a[5]={0,1,2,3,4};
*
* a[0]a[1]a[2]a[3]a[4]
* _____________________
* | 0 | 1 | 2 | 3 | 4 |
* —————————————————————
* ff40 ff44 ff48 ff52 ff56 内存地值 ，由于int为4个字节，所以第个元素的地址相隔4字节; 数组的内存地址为第一个元素的内存地址。
*
*/
//对函数的声名，以便使用
void printf_Array(int arr[],int len);
//数组的基本操作
void array_base() {
// int array[10] = {}; //这样也相当于赋了初值0，打印时全为0
// int array[10] = {0};//这样相当于给全部元素赋了初值0，打印时全为0
int array[10]; //这样是没有初始值 的数组，打印数是随机的，不确定的
int i;
for (i = 0; i < 10; i++) {
printf("%d ", array[i]); //遍历数组的每一个元素，进行打印输出
}
}
//数组的赋值与打印
void array_init_printf() {
int a[10]; //定义一个大小为10的整型数组
int i;
for (i = 0; i < 10; i++) {
a[i] = i; //从下标0开始，给数组元素赋值
}
//打印数组
for (i = 0; i < 10; i++) {
printf("%d ", a[i]); //遍历数组的每一个元素，进行打印输出
}
printf("\n");
}
/*
*使用一维数组程序处理Fibonacci数列(斐波那契数列)
*指的是这样一个数列：1、1、2、3、5、8、13、21、……在数学上，
*斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）
*/
void fibonacci() {
int i;
int f[20] = { 1, 1 }; //定义一个长度为20，并给下标 0，1元素赋初值
for (i = 2; i < 20; i++) {
f[i] = f[i - 2] + f[i - 1];
}
for (i = 0; i <20; i++) {
if (i!=0&&i % 5 == 0) {
printf("\n"); //每五个一行
}
printf("%12d", f[i]);
}
printf("\n");
/**
* output:
* 1 1 2 3 5
8 13 21 34 55
89 144 233 377 610
987 1597 2584 4181 6765
*/
}
/*数组的排序一：冒泡排序
冒泡排序算法的运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
*/
void bubble_sort(){
int a[5]={4,23,6,68,3}; //对这个随机数组进行排序
int j,i;
for(j=0;j<4;j++){
for(i=0;i<4-j;i++){
if(a[i]>a[i+1]){
int t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
}
}
printf_Array(a,5);//调用打印数组的函数进行输出
/*
* 输出：3 4 6 23 68
* 运行分析：
* j=0 i=0: a[0]>a[0+1] 4>23? 假，所以不调换位置 结果还是{4,23,6,68,3}
* j=0 i=1 a[1]>a[1+1] 23>6? 真，所以调换位置 结果是{4,6,23,68,3}
* j=0 i=2 a[2]>a[2+1] 23>68? 假，所以不调换位置 结果还是{4,6,23,68,3}
* j=0 i=3 a[3]>a[3+1] 68>3? 真，所以调换位置 结果还是{4,6,23,3,68}
* j=0 i=4 因i<4-0？ for(i=0;i<4-j;i++) 假，所以结束了j=0的这次循环了。
* j=1 i=0 a[0]>a[0+1] 4>6? 假，所以不调换位置 结果还是{4,6,23,3,68}
* j=1 i=1 a[1]>a[1+1] 6>23? 假，所以不调换位置 结果还是{4,6,23,3,68}
* j=1 i=2 a[2]>a[3] 23>3? 真 交换位置 结果是{4,6,3,23,68}
* 虽然这个时间排序已经正确的，但是这是随机的。系统是不会知道这个排序的，它还会一直这样执行下去
* 当：
* j=4时， 4<4 为假，就会结束了循环。这个时候得到的结果肯定是正确的了
*/
}
/*
* 数组的排序一：选择排序
* 简单选择排序的基本思想：
对于一个长度为n的数组进行简单的选择排序：
第1趟，在待排序记录a[0]~a[n-1]中选出最小的记录，将它与a[0]交换；
第2趟，在待排序记录a[1]~a[n-1]中选出最小的记录，将它与a[1]交换；
以此类推，第i趟在待排序记录a[i]~a[n-1]中选出最小的记录，将它与a[i]交换，
使有序序列不断增长直到全部排序完毕。
*/
void select_sort() {
int a[5]={4,23,6,68,3}; //对这个随机数组进行排序
int i,j;
for ( i = 0; i < 5 - 1; i++) {
int min = i;
for ( j = i + 1; j < 5; j++) {
if (a[j] < a[min]) { // 用后一个和第一个作比较 a[1]<a[0]
min = j; // 如果后一个比当前这个小，就记录下来
}
}
if (i != min) { //交换位置
int tem = a[i];
a[i] = a[min];
a[min] = tem;
}
}
printf_Array(a,5);
}
/*
* 对打印数组的功能进行封装成一个函数，以便快速打印数组
* 参数： arr[] 为要打印的数组
* len 数组的长度，由于c语言的数组不象java数组一样，提供一个length()函数获得数组的长度，所以要手动传入数组的大小
*/
void printf_Array(int arr[],int len){
int i;
for(i=0;i<len;i++){
printf("%d ",arr[i]);
}
printf("\n");
}
int main17() {
//由于所有函数在主函数前面定义，所以不用在这里声名
// array_base();
// array_init_printf();
// fibonacci();
// bubble_sort();
select_sort();
}
版权声明：本文为博主原创文章，未经博主允许不得转载。