C语言学习笔记:17_数组-一维数组(基本操作,选择和冒泡排序,斐波那契数列)

原创 2015年07月07日 09:48:04
/*
 * 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();

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

黑马程序员 C语言-----数组基本概念 以及选择 冒泡排序理解

数组基本概念  变量类型 变量名;      元素类型 数组名[元素个数]; // 数组中保存的每一个数据,我们称之为元素      特点:数组只能存放同一种数据类型      数组中的每...

C语言学习笔记分享之数组(冒泡排序)

//------------------整型变量修饰符 修饰符(int short long long long signed unsigned) 所有修饰符都是用来修整形 ...

C语言之数组冒泡排序法

  • 2009年12月02日 13:28
  • 181KB
  • 下载

C语言中用柔性数组实现斐波那契数列

一个柔性数组使用实例: #include #include typedef struct _soft_array { int len; int array[]; }SoftAr...
  • kangear
  • kangear
  • 2013年05月23日 18:52
  • 2489

斐波那契数列-数组和递归-C语言

兔子在出生两个月后,就有繁殖能力,一对兔子每一个月能生成一对小兔子来,假设所有的兔子都不死,那么一年之后可以繁殖多少对兔子? 这个问题就是 典型的 斐波那契数列 斐波那契数列的特点是: 前...

黑马程序员_C语言基础_数组之冒泡排序、快速选择排序、折半查找

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------       学习一维数组和二维数组的差别不大,学习方法可以通用,在学习过程中可以比较学习,找出...

黑马程序员——C语言基础--数组“冒泡排序”和“选择排序”详解及经典例子

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流! ----------------------...

C语言数组实现冒泡排序和选择排序程序

冒泡排序: 冒泡排序的的优点是好理解,稳定,再就是空间复杂度低,不需要额外开辟数组元素的临时保存控件,当然了,编写起来也容易。 其算法很简单,就是比较数组相邻的两个值,把大的像泡泡一样“冒...

韩顺平 javascript教学视频_学习笔记11_js二维数组_js冒泡排序_二分查找

多维数组——二维数组 多维数组我们只介绍二维数组,一维数组的元素还可以是一个数组,就构成了二维数组。 下面看两个程序即可 var ar...

黑马程序员-ios学习笔记 c语言 冒泡排序

// //  main.c //  maopao // //  Created by 蓝蓝 on 15/7/22. //  Copyright (c) 2015年 lanlan. All r...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C语言学习笔记:17_数组-一维数组(基本操作,选择和冒泡排序,斐波那契数列)
举报原因:
原因补充:

(最多只允许输入30个字)