冒泡排序算法教案

冒泡排序算法教案（精选6篇）

冒泡排序算法教案 第1篇

冒泡和递归一样，不管大家水平怎么样，基本上都能凑合的写写，快速排序其实主要的也是数据的交换，都算是交换排序，不过快排需要了解分治思想，实现的时候需要递归一下，导致很多时候看快排的时候都看的云里雾里，假设有一个无序的整型数组

索引0123456

数值1532899121736，

①取出0位的15作为基准值，然后倒序从后往前找小于15的，将12赋值给0位;

②从前往后找大于15的将32放置到位置4;

③位置1空出来，然后继续倒序找小于15的，正序找大于15的，最后索引到大3的时候重复以上过程。

冒泡排序

冒泡基本上没有什么好说的，直接看代码吧，新建了Sort类处理排序:

//

//Sort.h

//Algorithm

//www.cnblogs.com/xiaofeixiang

//Created by keso on 15/3/15.

//Copyright (c) 2015年 keso. All rights reserved.

//

#import

@interface Sort : NSObject

@property (nonatomic,strong)NSMutableArray *dataSource;

-(void)bubbleSort:(NSMutableArray*)dataSource;

-(void)quickSort:(NSInteger)start endIndex:(NSInteger)end;

@end

Sort.m中的bubbleSort实现:

//冒泡排序

-(void)bubbleSort:(NSMutableArray*)dataSource{

NSUInteger count=[dataSource count];

for(int i=0;i

for (int j=0; j

if ([dataSource[j] intValue]>[dataSource[j+1] intValue]) {

NSString*temp=dataSource[j];

dataSource[j]=dataSource[j+1];

dataSource[j+1]=temp;

}

}

}

for (NSInteger i=0; i<[dataSource count]; i++) {

NSLog(@”排序--%@“,dataSource[i]);

}

}

冒泡排序比较稳定，但是每次只是移动两个数字比较慢，如果是正序的话时间复杂度是O(n)，如果是逆序的需要弄成正序的，那么事件复杂度O(n*n)，会经过n(n-1)/2次比较，平均事件复杂度O(n*n);

快速排序

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)，

基本思路如下:

1.先从数组中取出一个数作为基准数值，也可以理解为中间变量。

2.分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3.再对左右区间重复第二步，直到各区间只有一个数。

快速排序由于排序效率在同为O(n*logn)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，也算是出门居家必备的算法了，理解比较好理解，具体的实现能写出来基本上算是理解的，至于更深的就要看工作中实际的操作过程啦。

Sort.h中定义了一个QuickSort方法，还有一个NSMutabArray是为了保存最后的结果的,具体实现:

//快速排序

-(void)quickSort:(NSInteger)start endIndex:(NSInteger)end{

if (start

NSInteger standardValue=[_dataSource[start] intValue];

NSInteger left=start,right=end;

while (start

//从后往前找，如果后面的数值大于基准值，递减

while (startstandardValue) {

end--;

}

//小于基准值的时候，给数组中索引为start赋值

if (start

_dataSource[start]=_dataSource[end];

start=start+1;

}

//从前往后找，如果数值小于基准值，递增

while (start

start++;

}

//大于基准值，给数组中索引为end的数据赋值

if (start

_dataSource[end]=_dataSource[start];

end=end-1;

}

}

//退出的时候值start和end相等

_dataSource[start]=[NSString stringWithFormat:@”%ld“,(long)standardValue];

[self quickSort:left endIndex:end-1];//处理左边

[self quickSort:end+1 endIndex:right];//处理右边

}

}

主函数中的调用如下:

NSMutableArray *data=[[NSMutableArray alloc] initWithObjects:@”10“,@”88“,@”97“,@”33“,@”8“,@”73“,@”18“, nil];

[sort bubbleSort:data];

sort.dataSource=data;

[sort quickSort:0 endIndex:[data count]-1];

for (int i=0; i<[data count]; i++) {

NSLog(@”排序:%@",data[i]);

}

return 0;

代码可能不是最简洁的，但是应该是比较好理解的，如果有问题，随时可以在评论区与我交流~

冒泡排序算法教案 第2篇

一、复习回顾

什么是排序：排序是把一个无序的数据元素序列整理成有规律的按排序关键字递增（或递减）排列的有序序列的过程。

/************************************************（已经学过的排序方法有：直接插入排序、希尔排序、直接插入排序：顺序的把待排序序列中的各个记录按其关键字的大小，插入到已排序的序列的适当位置。

希尔排序：（缩小增量排序），不断把待排序的记录分成若干个小组，对同一组内的记录进行排序，在分组时，始终保持当前组内的记录个数超过前面分组排序时组内的记录个数。）

************************************************/

二、第一小节（目标：理解掌握冒泡思想）

1、给出冒泡排序的定义（25分钟）

将待排序序列中第一个记录的关键字R1.key与第二个记录的关键字R2.key作比较，如果R1.key>R2.key，则交换记录R1和R2在序列中的位置，否则不交换；然后继续对当前序列中的第二个记录和第三个记录作同样的处理，依此类推，知道序列中倒数第二个记录和最后一个记录处理完为止，我们称这样的过程为一次冒泡排序。

2、请学生上台做排序练习（15分钟做题+10分钟讲解）（巩固排序思想的掌握）

第一题： 38 5 19 26 49 97 1 66 第一次排序结果：5 19 26 38 49 1 66 [97] 第二次排序结果：5 19 26 38 1 49 [66 97] 第三次排序结果：5 19 26 1 38 [49 66 97] 第四次排序结果：5 19 1 26 [38 49 66 97] 第五次排序结果：5 1 19 [26 38 49 66 97] 第六次排序结果：1 5 [19 26 38 49 66 97] 第七次排序结果：1 [5 19 26 38 49 66 97] 最后结果序列： 1 5 19 26 38 49 66 97

第二题： 8 7 6 5 4 3 2 1

数据结构——冒泡排序（第19讲，第9章）

答 第一次排序： 7 6 5 4 3 2 1 [8] 第二次排序： 6 5 4 3 2 1 [7 8] 第三次排序： 5 4 3 2 1 [6 7 8] 第四次排序： 4 3 2 1 [5 6 7 8] 第五次排序： 3 2 1 [4 5 6 7 8] 第六次排序： 2 1 [3 4 5 6 7 8] 第七次排序： 1 [2 3 4 5 6 7 8] 最后结果序列： 1 2 3 4 5 6 7 8

第二题： 1 2 3 4 5 6 7 8 第一次排序： 1 2 3 4 5 6 7 [8] 第二次排序： 1 2 3 4 5 6 [7 8] 第三次排序： 1 2 3 4 5 [6 7 8] 第四次排序： 1 2 3 4 [5 6 7 8] 第五次排序： 1 2 3 [4 5 6 7 8] 第六次排序： 1 2 [3 4 5 6 7 8] 第七次排序： 1 [2 3 4 5 6 7 8] 最后结果序列： 1 2 3 4 5 6 7 8]

从练习题中引出：一次冒泡排序的结果：使关键字最大的记录排在了序列的最后一个位置上。（这很重要，要强调）

比较后两题的题目区别和排序过程区别，作为课间思考题。（第二题是一组逆序数据，每一个排序都进行了数据交换，共进行了8-1=7次冒泡；第三题是一组正序数据，进行完一次排序后就发现，没有任何数据交换发生，后面进行的第二次到第七次冒泡的过程完全一样。）

三、第二小节

3、冒泡排序终止的条件（20分钟）

课堂思考题：考虑任何一组序列最多进行多少次冒泡排序就可保证顺序一定已经排好了。

思考：如果序列初始顺序是逆序，需要进行多少次排序（要记住，数据结构——冒泡排序（第19讲，第9章）

每次冒泡排序的结果：可以保证最大的记录在最后一个位置上）。如果序列初始顺序是正序，需要进行多少次排序就可以保证数据序列顺序。如何使排序过程适可而止？既排好序又不多余进行？

当计算机对一组数据进行排序之前，并不知道该组数据是什么顺序，因此，必须要进行至少一次的比较和排序，当某一比较和排序进行完之后发现没有任何数据交换发生，证明任何相邻的两数都符合目标顺序要求，因此，也不必再进行下一下比较排序了。

结论：当进行某次冒泡排序时，若没有任何两个记录交换位置，则表明序列已排好，此时排序可结束。

4、用文字（伪码）描述冒泡排序算法（15分钟）思考方法：

首先是对数组的相邻的两数比较，根据比较结果确定是否交换位置；这种比较进行的次数比数据列中数据个数少1；

（此两步完成了一次冒泡排序）

对一个序列来说，共进行多少次冒泡排序呢？最多和上面第二步的比较次数一样，但也可提前结束，只要在某一遍冒泡中没有发生数据交换即可。如何确实是否发生数据交换，在程序中，可以考虑设置一个标志位，当发生数据交换时，更改标志位，每次重新进行冒泡排序之前可以检查标志位，如果没有发生改变，则可证明上一次冒泡已经没有数据交换发生，也就是说数据序列已经排好，可以停止进行冒泡排序。

冒泡算法函数 { 设置标志位；

//以下循环用来控制冒泡排序进行的次数

数据结构——冒泡排序（第19讲，第9章）

for循环（对n个数据的序列进行n-1次冒泡，但是如果没有交换发生则跳出该循环）{ //以下循环用来对该数据序列进行一次冒泡排序 for（单次冒泡排序需要进行n-1次）{ 比较相邻两数的大小；

if(前大后小){ 交换 } else //前小后大 {

位置不变 } } } }

5、回顾总结冒泡排序的思想（10分钟）本节课：

1.首先回顾了什么是排序；

2.然后介绍了冒泡排序的思想；（每次冒一个泡泡，把最大的冒到最后）3.我们通过三道练习题对一组无序数据进行了排序；

4.通过练习题我们看出来，数据初始序列越接近目标序列，冒泡的次数越少；因此我们总结出了冒泡排序最多进行的次数和终止的条件； 5.最后，我们根据冒泡排序的思想用文字描述了冒泡函数的构成方法；

四、课后作业

1、用冒泡排序法对数字序列进行排序（要写出6次排序步骤）

55 48 37 10 90 84 答 55 48 37 10 60 84 90 48 37 10 55 60 84 90 37 10 48 55 60 84 90 10 37 48 55 60 84 90

数据结构——冒泡排序（第19讲，第9章）

10 37 48 55 60 84 90

2、用C语言描述冒泡排序算法。

Void BubbleSort(elemtype x[],int n)//传入序列和序列数字个数 {

int i,j,flag=1;elemtype

《冒泡排序算法》教学设计 第3篇

通过前面的学习, 学生已经了解了算法设计的基本知识, 学会了利用自然语言和流程图描述解决问题的算法, 对排序中遇到的循环结构流程图、循环语句以及数组变量的使用方法都已有基础。但由于实践较少, 他们对以前知识的遗忘率比较高, 画流程图还不够熟练, 程序设计思想比较弱。

程序设计的基本方法是自顶向下、逐步求精和模块化。依据这一方法, 教师采用讲解法、演示法、讨论合作法、分析归纳法, 引导学生参与思考, 逐步降低学生的理解难度, 化抽象为具体, 有效地将各个难点分解和突破。

一、教学目标

知识目标:掌握冒泡排序的原理, 理解冒泡排序的流程图, 学会编写冒泡排序程序的主要代码。

能力目标:学会使用冒泡排序思想设计解决简单排序问题的算法;进一步理解程序设计的基本方法, 体会程序设计在现实中的作用;培养分析问题、发现规律的能力。

情感目标:提高学习热情, 培养良好的程序书写习惯。

二、教学重点与难点

重点:理解冒泡排序原理及其流程图。

难点:理解冒泡排序中的遍、次等概念 (即对变量使用的理解) 。

三、课前准备

资源准备:冒泡排序的课件。

教学环境的设计与布置:多媒体网络教室、投影机、多媒体教学平台、F l a s h软件。

四、教学过程

1. 导入:创新情景

师:生活中, 我们经常会碰到要排队的情况, 比如排座位、排队做操、排队大合唱等。今天, 我想请4位同学上来表演一下排队。

我按学号顺序点4位学生的名字, 让他们上来, 并让他们按报到的次序排列。

师:他们现在是按什么排的?

生:学号。

师:好, 现在请你们按身高从低到高排列。

不一会儿, 4位学生就排好了。其他学生的注意力也集中了过来。

师 (指着其中一位换到前面去的学生问大家) :他是怎么知道自己矮的。

生:一看就知道了。

师:那请这位学生谈谈你当时的想法。

这时一般学生会提到与别人比一下, 矮的话就换到前面去了 (如果说不出来, 教师可做适当引导) 。

师:对, 肯定要比一下才知道, 而且需要交换。有些学生说一看就知道, 其实也是看了以后经过大脑思维飞快地比较而得出的结论。排队其实是一种排序——通过调整位置, 把杂乱无章的数据变为有序的数据, 如E x c e l中的排序功能。通过本节课的学习, 我们自己也可以设计出类似的小软件。

2. 冒泡排序的基本思想

师:排序的方法很多, 这节课我们来学习其中一种比较典型的排序方法——冒泡排序。

教师先让学生根据字面意思想象一下“冒泡”是一个怎么样的情景——气泡一个一个地由下而上依次冒上来。接下来, 教师一边讲解一边以文字形式给出冒泡排序的基本思想 (教材P 3 1, 略) 。特别要强调怎样算一遍处理, 而且每遍总是从最下面起, 自下而上, 比较相邻的两个数。

教师再让刚才那4位学生仍先按学号排回来, 演示利用冒泡排序法进行从低到高排序的过程。在学生表演时, 教师充当解说员, 在关键处 (如每遍的开始和结束) 进行提示, 并引导学生认识到第几遍处理完后找到的应该是第几矮的同学 (或第几小的数) 。

设计意图:学生的表演比单纯拿出几个数来比较更能吸引学生的注意力, 在这种轻松活跃的气氛中, 学生很快明确了冒泡排序的基本方法。

师:4位学生共进行了几遍查找?为什么?

教师再用一个Flash动画演示规模为4的数组按非减次序进行逐个冒泡排序的过程, 再次强化学生对冒泡排序过程的理解, 也为下面每一遍中两两交换情况的分析做了铺垫。

3. 画流程图 (按非减次序排序)

这一环节是本节课的重点。教师采用自顶向下、逐步求精的方式, 由特殊到一般归纳总结, 各个难点一一突破。

教师以具体的4个数为例, 由最简单的流程图1左侧的图开始, 让学生将冒泡排序过程用形象的语言表示出来:不断冒起一个泡 (最小数) , 转化成右侧流程图。

思考:以4个数为例, 这里的“不断”有没有限定, 到底是几遍呢?为什么?进而带领学生画出流程图2左侧的流程图。

得出流程图2左侧的图之后, 教师让学生思考:这种结构实际上属于什么结构? (循环结构) 但是左图是不规范的, 需要用一个变量来控制循环次数, 从而引出用变量i来记录正在执行的排序的遍数, 它的值应该是从1到3, 每次做完后加1。学生回顾循环结构的流程图模式, 两两讨论, 合作将流程图2左侧的图转换成右侧规范的流程图。

思考:如果参与排序的是n个数呢?

比较遍数与个数关系:遍数=个数-1

为了分解后面的一个难点, 教师让学生用简单的语言描述每次“冒起一个最小数”是怎么冒出来的:不断两两比较交换, 这也是冒泡排序的原理。于是图2右侧流程图又可转化成流程图3的形式。

设计意图:遍数与个数关系运算是本课的一个难点, 但学生还是可以比较容易地得出这个结论的。所以将上面流程图中的“i<=3”改成“i<=n-1”即可得到流程图了。

现在只剩下“不断两两比较交换”还需要进一步细化。教师以4个数为例, 回顾刚才的F l a s h动画。

在程序中有些数据规律不很明显, 教师用表格列出来, 以提高学生分析数据的有效性和准确性, 规律也更易找出来。

教师引导学生发现规律:每次都是从最后一个数开始比较, 最后一个参与比较的数的下标与比较的遍数有关, 即遍数+1。教师让学生思考:n个数的情况如何比较呢?学生讨论共n个数、各遍比较的情况, 特别是第i遍, 完成下表的填写:

这里又需要用一个变量来标识正在参加比较的数组元素的下标, 引进变量j:记录一遍处理过程中, 当前数组元素的下标。

小结论:共n个数, 第i遍处理时, j的值从n到i+1之间递减, 每次d (j) 与它的前一个数d (j-1) 进行比较。

设计意图:本节课最大的难点就是变量j的取值范围, 尤其对“它的终值为什么是i+1”学生更是难以理解, 因为它是在动态变化的。由特殊的4位数开始找出规律, 然后归纳推广到一般的n个数就相对简单。我花了较长的时间让学生自己探讨, 目的是经过充分思考得出的结论才会记忆深刻。

为了加深学生理解, 我一边讲解, 一边手绘了如下的图形, 以更直观地来说明这个问题:当要进行第i遍处理时, 即要找第i个最小数时, 此时前面i-1个最小数已经找到 (阴影部分) , 这部分不需要再参与以后的两两比较, 所以第i遍处理时, 第一次两两比较应该是d (n) 与它的前一个数d (n-1) 。以此类推, 最后要比的是d (i+1) 与它的前一个数d (i) 。至此, 该轮最小数就冒到第i个位置了。所以最后一个的“它”的位置应该是i+1。

“如果下面一个数比上面一个数小, 就交换”。这是一种分支结构。教师用生活中的实例说明 (如果天气好的话就去打球;如果60分以上就显示合格, 否则就显示不合格) , 并简单回顾分支结构的流程示意图。

设计意图:程序实例生活化学生更容易接受。

师生得出不断两两比较交换的流程图, 如流程图4。

至此, 所有问题、难点我们都全部细化, 一一解决了, 现在将流程图4“两两比较交换”纳入流程图3, 即得下面的总流程图。

n:参加排序的数组元素总个数。i:记录正在执行的排序的遍数, 由1变到n-1。j:记录一遍处理过程中, 当前数组元素下标, 由n变到i+1。说明:虚线框部分即为第i遍处理时“不断两两比较交换”的流程图。

当出示这个总流程图时, 学生发出惊叹, 他们不太相信自己的眼睛。

师:不要惊讶, 这的确是我们通过自己的努力一起画出来的。看来设计算法、画出流程图也并不是什么难事。只要我们有信心, 由浅入深还是可以解决的。

教师说明这个总流程图各部分的作用, 并留几分钟让学生自己消化新学知识。

4. 学生体验冒泡排序“算法执行过程”

让学生采用“单步执行”模式观看本书配套辅助软件“运行体验”文件夹中的“冒泡排序.s w f”, 体验冒泡排序的算法执行过程。

5. 流程图→程序语言

可以通过对两个变量和两数互换语句的解决, 最终得到主要参考代码。

(1) i:记录正在执行的排序的遍数, 由1到n-1

for i=1 to n-1

冒起一个最小数 (循环体)

next i

(2) j:记录一遍处理过程中, 当前数组元素下标, 由n变到i+1

for j=n to i+1 step-1

d (j) 与它的前一个数d (j-1) 进行比较

next j

(3) d (j) 与d (j-1) 互换

k=d (j) :d (j) =d (j-1) :d (j-1) =k

教师可以利用酱油和米醋互换来做比喻, 引导学生实现两数互换的方法。

对照总流程图, 自上往下, 写出主要参考代码:

for i=1 to n-1'i记录正在执行的排序的遍数, 由1变到n-1

for j=n to i+1 step-1'j记录一遍处理过程中, 当前数组元素下标, 由n变到i+1

互换

设计意图:因为已学过VB基本知识, 学生对赋值、选择和循环这三种语句都有基础, 所以流程图画出来以后, 转换成程序语言并不太难。教师趁热打铁, 顺理成章地完成了主要代码的编写, 为下节课学生上机实践打下基础。

显示参考代码后, 教师要引导学生养成良好的习惯, 使用规范的代码书写格式, 不仅有利于程序的调试, 还增加了可读性。

6. 拓展:优化冒泡排序

教师让学生到网上搜索冒泡排序的改进方案。

设计意图:为寻找解决问题的最佳方案而产生更好的学习目标。尤其是一些理科比较好, 又对程序设计比较感兴趣的学生, 离开机房的时候还一路在讨论着。

7. 作业设计

设计一个评分系统的流程图:有n个评委, 最后得分为去掉一个最高分与一个最低分后的平均分。

五、问题研讨

1. 如何用人的思维模拟计算机的工作过程

我让学生上来排队演示, 本想让他们用不同方法, 以便引出各种排序方式。但后来发现这太难了。因为人是有眼睛和原有认知能力的, 有些事想当然就可以完成判断。但计算机与人不同, 它看不见、摸不着这些数据, 不可能像人一样来完成任务。解决问题的关键, 就是要把人解决问题的每一步思维过程描述出来。这也是所有学程序的人尤其是初学者感觉最难的地方。并且, 程序设计思想并不是一下子就能培养的, 我们高中阶段只能是慢慢引导学生学着去分析问题, 将问题解决方法步骤化。所以课后我一直在思考, 是否可以在上这部分内容之前给学生布置一个任务:闭上眼睛, 将十根乱排的长短相差不大的小木棍从短到长排起来, 要求每次最多只能比较两根。事后我也请一些人做过实验, 发现每个人都有自己不同的想法, 但都可以从程序设计的各种排序法中找出原型。

2. 细节也不容忽视

冒泡排序算法教案 第4篇

关键词：冒泡排序；趣味；改进；交换次数；有序表

中图分类号：TP301.6

在众多的排序方法中，冒泡排序算法由于其简洁的思想及其稳定性而得到广泛的应用。本文主要对传统的冒泡排序算法的基本原理进行了介绍和分析，综合趣味和性能两方面提出了改进算法，提高了算法的效率和实用性。

1 传统的冒泡排序算法

以升序排序为例，传统冒泡排序算法的基本思想是，依次比较待排序数据中的两个相邻的数，如逆序，则进行交换，将小的调到前头，直到最后两个数进行过比较为止。上述过程称为第一趟排序，其结果是让最大的数“沉淀”到最后的位置。然后再进行下一趟排序，直至整个数据序列有序为止。由于整个排序过程，总是将较大的数据向下“沉”，而较小的数据向上“浮”，如同水中的气泡逐步冒出水面一样，“冒泡排序”因此得名[1]。如果待排序数据序列中包含n个数据，最终使整个序列有序需要经过n-1趟排序来完成。

2 冒泡排序算法的分析与改进

2.1 从趣味上改进冒泡排序算法

传统的冒泡排序算法很生硬地将一些数据的两两比较提出来，没有给数据赋予具体的情景和角色，人们只能靠反复加强记忆来想象两两比较的过程和数据交换的过程，这样使得冒泡排序很枯燥抽象。目前许多改进的冒泡排序算法都是从算法的性能上进行优化，没有在趣味上进行探索的，这不利于算法的普及和扩展。为了解决这个问题，下面我们针对趣味性方面对传统的冒泡排序算法进行改进。趣味冒泡排序算法的思想是：以升序排序为例，把等待排序的数据列表看成用隔离墙分成有序和无序的两个子表；从远离有序表的一端开始，对无序表中的数据进行两两比较，如逆序，就交换，等所有元素比较完毕，最小的元素就移到了無序表靠隔离墙的那端，然后隔离墙向无序表方向移动一个位置；这样就完成了一趟冒泡排序过程。给定含n个元素的一个表，需要进行n-1趟冒泡排序的过程[2]。图2显示了趣味冒泡排序的原理。图3显示了含5个元素的数组趣味冒泡排序的过程。

2.2 从性能上改进冒泡排序算法

以升序排序为例，传统的冒泡排序算法中，一般是以大数往后沉的方式来实现，很多情况下都有几趟排序是不会有任何的操作，这种做法会出现大量的无效操作，造成资源的浪费。为了避免这种情况，可以使用一个标记变量来解决，即当排序不发生任何数据交换时，则终止排序。这样的解决办法既避免了无效的重复排序，又避免了有限资源的浪费。

在上面趣味冒泡排序算法中，k就是用来标记交换次数的标记变量。这样在趣味冒泡排序算法基础上从性能上改进冒泡排序算法，只需增加一条语句“if（k==0）break；”即可。用C语言描述基于趣味的改进的冒泡排序算法如图5所示。

目前从性能上改进冒泡排序算法，除了增加标记交换次数的变量，还有双向冒泡排序[3]、交替排序法[4]等。这些改进的冒泡排序算法都可以结合趣味性，形成更形象生动、性能更优的算法。

2.3 改进前后冒泡排序算法有限性分析验证

引入10个待排序的数据：1，20，100，-2，15，8，-100，56，43，12，使用传统冒泡排序算法，需要9趟排序才能得到有序的列表，使用趣味冒泡排序算法，需要8趟就能得到有序列表，使用趣味改进的冒泡排序算法仅需要7趟就能得到有序列表。可见本文提出的改进的算法可以提高算法执行效率，是有效的。

3 结束语

本文对传统的冒泡排序算法进行了分析，发现传统的冒泡排序方法可能会产生一些不必要的操作，而且在趣味性方面也欠缺。在此基础上，本文提出了基于趣味的改进冒泡排序算法，提高了算法的执行效率和实用性。

参考文献：

[1]宋美英.基于C语言的冒泡排序算法探讨[J].现代计算机，2011（12）：48-49.

[2]葛日波.C语言程序设计[M].北京：北京邮电大学出版社，2008：126-127.

[3]淦艳等.冒泡排序算法及其改进算法的实验分析[J].重庆三峡学院学报，2011（03）：53-57.

[4]蓝超.冒泡排序算法的优化[J].兵工自动化，2006（25）：50-52.

作者简介：李秋（1979-），女，讲师，硕士，研究方向：计算机网络编程。

冒泡排序算法教案 第5篇

包括冒泡排序、并归排序、插入排序、选择排序、快速排序、堆排序、Shell排序 ——————sort_all.h文件—————————————————— #include using namespace std;/****************************************/ class sort_all { public: void swap_i(int &a, int &b;void disp_array(int *array, int len;void disp_num(;void sort_maopao(int *array, int len;void sort_quick(int *array, int start, int end;void sort_merge(int * array, int start, int end;void sort_heap(int *array, int len;void sort_select(int *array, int len;void sort_insert(int *array, int len;void sort_shell(int *array, int len;};——————————————————————————————————————

————————sort_real.cpp文件——————————————————————

#include “sort_all.h”

void sort_all::disp_array(int *array, int len { for(int i=0;i { cout << array[i] << “ ”;} cout << endl;} void sort_all::swap_i(int &a, int &b { int temp;temp = a;a = b;b = temp;} void sort_all::disp_num({ cout << “---冒泡排序，输入1---” << “n”;cout << “---并归排序，输入2---” << “n”;cout << “---插入排序，输入3---” << “n”;cout << “---选择排序，输入4---” << “n”;cout << “---快速排序，输入5---” << “n”;cout << “----堆排序，输入6----” << “n”;cout << “--Shell排序，输入7---” << “n”;cout << “-----结束，输入0-----” << “n”;

} /**************************************************/ /**************堆排序 ******************************/ /**************************************************/ void heap_adj(int *array, int i, int len { int nTemp;int nChild;for(nTemp = array[i];2*i+1 { nChild = 2*i+1;if(nChild nChild ++;if(nChild < len-1 && array[nChild]>nTemp array[i] = array[nChild];else break;array[nChild] = nTemp;} } void heap_create(int *array, int len { for(int i=len/2;i>=0;i--heap_adj(array,i, len;}

void sort_all::sort_heap(int *array, int len { heap_create(array, len;for(int i=len-1;i>0;i--{ swap_i(array[0], array[i];heap_adj(array, 0, i;} } /*******************************************************/ /******************插入排序*****************************/ /*******************************************************/ void sort_all::sort_insert(int *array, int len { int i,j;int temp;for(i=1;i { temp = array[i];for(j=i;j>0 && array[j-1] > temp;j--array[j] = array[j-1];array[j] = temp;} } /********************************************************/

/*************冒泡排序***********************************/ /********************************************************/ void sort_all::sort_maopao(int *array, int len { int i,j;for(i=0;i { for(j=len-1;j>=i;j--{ if(array[j] > array[j+1] swap_i(array[j],array[j+1];} } } /**********************************************/ /**************并归排序************************/ /**********************************************/ void merge(int * array, int start, int mid, int end { int len_A = midmid;int *A = new int[len_A];int *B = new int[len_B];int i,j;for(i=0;i

A[i] = array[i +start];for(i=0;i B[i] = array[i + mid+1];i=0;j=0;int temp;int k=start;while(i { if(A[i] > B[j] { temp = A[i];i++;} else { temp = B[j];j++;} array[k++] = temp;} while(i { array[k++] = A[i++];}

while(j { array[k++] = B[j++];} } void sort_all::sort_merge(int * array, int start, int end { if(start == end return;else { int mid =(start+end/2;sort_merge(array, start, mid;sort_merge(array, mid+1, end;merge(array, start, mid, end;} } /********************快速排序******************************/ /**********************************************************/ void sort_all::sort_quick(int *array, int start, int end { int key = array[start];int i = start;int j = end;if(i>=j

return;while(i { while(i j--;array[i] = array[j];while(i = array[i] i++;array[j] = array[i];} array[i] = key;sort_quick(array, start, i-1;sort_quick(array, i+1, end;} /****************************************************/ /****************选择排序****************************/ /****************************************************/ void sort_all::sort_select(int *array, int len { int i,j;int ntemp;int key;for(i=0;i { key = array[i];

ntemp = i;for(j=i+1;j { if(array[j] < key && array[ntemp] > array[j] ntemp = j;} swap_i(array[i], array[ntemp];} } /*****************************************/ /**************** Shell排序****************/ /*****************************************/ void sort_all::sort_shell(int *array, int len { int step = len;int i;while(step >1 { step =(step+1/2;for(i=0;i { if(array[i+step] < array[i] swap_i(array[i+step], array[i];} }

} ————————————————————————————————————————————————————sort_main.cpp文件————————————————— #include “sort_all.h” int main({ int input[] = {2,4,5,1,5,8,10,-2,4};int len = sizeof(input/sizeof(int;int N;sort_all instance;while(1 { instance.disp_num(;cout << “请输入: ”;cin >> N;if(N==0 break;cout << “-” << “n”;cout<< “原始数据：” << “n”;instance.disp_array(input, len;switch(N { case 1: instance.sort_maopao(input, len;cout << “冒泡排序结果：” << “n”;

break;case 2: instance.sort_merge(input, 0, len-1;cout << “并归排序结果：” << “n”;break;case 3: instance.sort_insert(input, len;cout << “插入排序结果：” << “n”;break;case 4: instance.sort_select(input, len;cout << “选择排序结果：” << “n”;break;case 5: instance.sort_quick(input, 0, len-1;cout << “快速排序结果：” << “n”;break;case 6: instance.sort_heap(input, len;cout << “堆排序结果：” << “n”;break;case 7: instance.sort_shell(input, len;cout << “Shell排序结果：” << “n”;default:

冒泡排序说课稿 第6篇

各位评委大家好，很高兴能给我十分钟的时间和大家交流。我叫周芮，来自09教技。今天我要说课的课题是《冒泡排序》。该课选自浙教版《算法与程序设计》。排序算法是本书中比较精彩但也是相对较难的部分之一，它的内容丰富，形式多样。而冒泡排序又是相对简单的一种排序方法。它是本章的第一课时，在本章中起着示范作用，所以讲好这节课是教好以后的课的关键。

综合以上几点，我将本课的教学目标制定如下： 知识与技能：

掌握冒泡排序的原理；

理解冒泡排序的流程图

过程与方法：

通过游戏中对人物财富的排序，理解冒泡排序的基

本原理和方法；

通过归纳冒泡排序算法来编写流程图

情感态度价值观：培养学生分析问题以及解决日常生活中实际问题的人能力，发现规律的能力。并激发学生主动学习的兴趣

基于对教材的理解，我将本堂课的重点定为掌握冒泡排序的算法，难点为归纳算法，用流程图表示。

我们现在面对的学生是所谓的90后，他们普遍具有创造性，容易接受新事物，善于发现的特点。他们对认知规律从感性逐步提升到了理性。而且学生有个普遍的特性就是爱玩，这是他们的天性。基于这一特点，我将会用游戏来引发他们的学习兴趣。在知识准备方面，学生

先前已经学过了算法的表示方法，三种基本结构，熟悉了变量的运用，能用算法描述一般问题的解决步骤。

在教法方面，我将选用演示法、任务驱动法、练习法。

在学法方面，主要是听讲法和自主探究学习法，通过老师讲解以及自己的亲身体验来探究算法的原理。

《师说》中提到，“师者，传到授业解惑也”，教学也就是为学生解决疑惑的。我的教学过程也就围绕“惑”这个字展开，我称之为“惑之四部曲”。

第一部曲是“遇惑”。我先创设一个游戏情境——大富翁，这是一款比较普遍的游戏，容易引起学生的共鸣，从而引发学生的学习兴趣。利用游戏中的一个情景——财富排行榜，来引出教学内容。首先我展示的排行榜上可能只有几个人，同学们能够很轻易地给出结果，可是当人数增多的时候，同学们就会觉得比较困难，当人数到达一定的数量后同学们会觉得这简直是不可能完成的任务。这样，老师就可以引出学习的内容——冒泡排序。

这一设计，我主要考虑到学生对数量少的数据能够比较容易地完成而不是通过考虑“按什么方法完成的”。这样增加难度后可以让学生体会到算法的好处，从而引起主动学习的兴趣，可以自然引出冒泡排序算法的思想。第二部曲是“析惑”。

为了让同学们脑海中模糊的思想变清晰，我准备了一个FLASH课件小游戏，内容就是大富翁的财富排行榜。我制定这么一个规则：将财富从少到多排列。可以通过从右往左的顺序两两进行对比，将较低的人往左排。

通过这样一个环节，可以让同学们比较直观的感受到冒泡算法的思想，是如何进行的。第三部曲是“解惑”

首先我会请同学用自然语言来描述算法的思想，我进行小结。接着我将继续提问如何用流程图表示。在这里我先会引入一个数组的概念，用板书演示。为了让同学更加透彻了解算法，我会用数组来演示详细的过程。用变量i表示趟值，用j表示带比较数组的位置。若d(j)

在课堂快结束时我将会进行课堂小结，回顾本堂课的知识点提问让同

学回答算法思想，达到巩固的目的。

最后一部曲是“扫惑”。我会给同学们布置一个任务，给出一张成绩单，上面印有一个同学的各科的考试成绩。让同学们用冒泡排序算法写出各趟排序结果并上交。这样可以及时检测同学们是否学会了。得到及时的反馈。

总结：因为这堂课相对而言是比较难的，如何长时间吸引学生的注意力是我要考虑的一个问题。为此，我进行了如下设计：

1、用游戏引入课堂，逐步加深问题的难度

2、用FLASH课件演示

3、用表格列举