labview数组排序算法.docx
《labview数组排序算法.docx》由会员分享,可在线阅读,更多相关《labview数组排序算法.docx(15页珍藏版)》请在冰豆网上搜索。
labview数组排序算法
18.2.2冒泡排序
“冒泡”是什么意思?
湖底有时会冒出一个气泡,气泡刚在湖底时,是很小的,在向上浮的过程中,才一点地慢慢变大。
学过高中的物理的人,应该不难解释这一现象。
冒泡排序的过程有点类似这个过程,每前进一步,值就大一点。
排序当然有两个方向,一种是从小排到大,一种是从大排到小。
大多数教科书里都讲第一种,我们也如此。
这样一来,冒泡排序法就改为“沉泡法”了,较大值一点点跑到数组中的末尾。
一般教科书里也会说,冒泡排序法是人们最熟悉,及最直观的排序法,我可不这样认为。
或许老外在生活中用的是这种最笨的排序法?
我猜想,大家在生活中99%使用后面要讲的“选择”排序法。
冒泡排序是这么一个过程(从小到大):
1、比较相邻的两个元素,如果后面的比前面小,就对调二者。
反复比较,到最后两个元素。
结果,最大值就跑到了最末位置。
2、反复第一步,直到所有较大值都跑到靠后的位置。
看一眼例子:
2,5,1,4,3
第一遍:
·比较第一对相邻元素:
2,5,发现后面的5并不比2小,所以不做处理。
序列保持不变:
2,5,1,4,3
·继续比较后两对元素:
5,1,发现后面的1比前面的5小,所以对调二者。
现在,序列变为:
2,1,5,4,3
·继续比较后两对元素:
5,4……对调,于是:
2,1,4,5,3
·继续比较后两对元素:
5,3……对调,于是:
2,1,4,3,5<-----OK,现在最大值5跑到最尾处了。
大泡泡“5”浮出来了,但前面的2,1,4,3,还是没有排好,没事,再来一遍,不过,由于最后一个元素肯定是最大值了,所以我们这回只排到倒数第二个即可。
第二遍:
·比较第一对相邻元素:
2,1,发现1比2小,所以对调:
1,2,4,3,5
·继续比较后两对元素:
2,4,不用处理,因为后面的数比较大。
序列还是:
1,2,4,3,5
·继续4,3,对调:
1,2,3,4,5。
前面说,5不用再参加比较了。
现在的序列是1,2,3,4,5。
接下来,我们再来一遍:
第三遍:
·比较第一对相邻元素:
1,2:
不用对调。
……等等……
有人说,现在已经是1,2,3,4,5了,完全是排好序了啊,何必再来进行呢?
我们确实是看出前面1,2,3也井然有序了,但对于程序来说,它只能明确地知道自己已经排好了两个数:
4,5,并不知道的1,2,3凑巧也排好了。
所以它必须再排两次,直到确认把3和2都已推到合适的位置上。
最后剩一个数是1,因为只有一个数,没得比,所以这才宣告排序结束。
那么到底要排几遍?
看一看前面的“第一遍”、“第二遍”的过程你可发现,每进行一遍,可以明确地将一个当前的最大值推到末尾,所以如果排Count个数,则应排Count遍。
当然,最后一遍是空走,因为仅剩一个元素,没得比较。
下面就动手写冒泡排序法的函数。
写成函数是因为我们希望这个排序法可处理任意个元素的数组。
//冒泡排序(从小到大):
//num:
要接受排序的数组
//count:
该数组的元素个数
voidbubble(intnum[],intcount)
{
inttmp;
//要排Count个数,则应排Count遍:
for(inti=0;i {
for(intj=0;j {
//比较相邻的两个数:
if(num[j+1] {
//对调两个数,需要有"第三者"参以
tmp=num[j+1];
num[j+1]=num[j];
num[j]=tmp;
}
}
}
}
注意在内层循环中j的结束值是count-i-1。
要理解这段代码,明白为什么结束在count-i-1?
如果你忘了如何在CB进行代码调试,如果设置断点,如何单步运行,如何观察变量的值,那么你需要“严重”复习前面有关“调试”的章节;如果你一直是高度着每一章的程序到现在,那么你可以继续下面的内容。
排序函数写出一个了,如何调试这个函数?
在CB里新建一空白控制台程序,然后在主函数里,让我们写一些代码来调用这个函数,并且观察排序结果。
#include
……
voidbubble(intnum[],intcount)
{
……
}
intmain()//我实在有些懒得写main里两个参数,反正它们暂时对我们都没有用,
//反正CB会为你自动生成,所以从此刻起,我不写了,除非有必要。
{
intvalues[]={2,5,1,4,3};
intcount=sizeof(values[])/sizeof(values[0]);
bubble(value,sizeof);
}
你要做的工作是单步跟踪上面的代码,看看整个流程是不是像我前面不厌其烦的写的“第一遍第二遍第三遍”所描述的。
完成上面的工作了吗?
全部过程下来,只花20分钟应该算是速度快或者不认真的了(天知道你是哪一种?
天知道你到底是不是没有完成就来骗我?
)。
现在让这个程序有点输出。
我们加一个小小的函数:
//输出数组的元素值
//num:
待输出的数组
//count:
元素个数
voidprintArray(intnum[],intcount)
{
for(inti=0;i {
count< }
cout<}
把这个函数加到main()函数头之前,然后我们用它来输出:
intmain()//我实在有些懒得写main里两个参数,反正它们暂时对我们都没有用,
//反正CB会为你自动生成,所以从此刻起,我不写了,除非有必要。
{
intvalues[]={2,5,1,4,3};
intcount=sizeof(values[])/sizeof(values[0]);
cout<<"排序之前:
"< printArray(values,count);
//冒泡排序:
bubble(value,sizeof);
cout<<"排序之后:
" < printArray(values,count);
system("PAUSE");
}
后面要讲的其它排序法也将用这个printArray()来作输出。
冒泡排序是效率最差劲的方法(速度慢),不过若论起不另外占用内存,则它当属第一。
在交换元素中使用了一个临时变量(第三者),还有两个循环因子i和j,这些都属于必须品,其它的它一个变量也没多占。
我们现在讲讲如何避免数据其实已经排好,程序仍然空转的的局面。
首先要肯定一点,至少一遍的空转是不可避免的,这包括让人来排,因为你要发现结果已是1,2,3,4,5了,你也是用眼睛从头到尾抄了一遍(如果你视力不好,说不定还要扫两遍呢)。
接下来一点,我们来看看除了第一遍空转,后面的是否可以避免。
冒泡排序法的空转意味着什么?
因为算法是拿相邻的两个比较,一发现次序不合“从小到大”的目的(小的在大的后头),就进行对调。
所以如果这个对调一次也没有进行,那就说明后面的元素必然是已经完全有序了,可以放心地结束。
让我们来加个变量,用于标志刚刚完成的这一遍是否空转,如果是空转,就让代码跳出循环。
//冒泡排序(从小到大,且加了空转判断):
voidbubble(intnum[],intcount)
{
inttmp;
boolswapped; //有交换吗?
//要排Count个数,则应排Count遍:
for(inti=0;i {
//第一遍开始之前,我们都假充本遍可能没有交换(空转):
swapped=false;
for(intj=0;j {
//比较相邻的两个数:
if(num[j+1] {
swapped=true; //还是有交换
//对调两个数,需要有"第三者"参以
tmp=num[j+1];
num[j+1]=num[j];
num[j]=tmp;
}
}
if(!
swapped)
break;
}
}
加了swapped标志,这个算法也快不了多少,甚至会慢也有可能。
冒泡排序还有一些其它的改进的可能,但同样作用不大,并且会让其丧失仅有优点“代码简单直观”。
所以我个人认为真有需要使用冒泡排序时,仅用最原汁原味的“泡”就好。
必竟,你选择了冒泡算法,就说明你对本次排序的速度并无多高的要求。
对于n个元素,原汁原味的“冒泡排序”算法要做的比较次数是固定的:
(n -1)*n/2次的比较。
交换次数呢?
如果一开始就是排好序的数据,则交换次数为0。
一般情况下为3*(n-1)*n/4;最惨时(逆序)为3* (n-1)*n/2。
冒完泡以后——情不自禁看一眼窗台罐头瓶里那只胖金鱼——让我们开始中国人最直观的选择排序法吧。
对了,补一句,如果你看到有人在说“上推排序”,那么你要知道,“上推排序”是“冒泡排序”的另一种叫法,惟一的区别是:
它不会让我们联想到金鱼。
18.2.3选择排序
本章前头我们讲了“求最值”的算法,包括最大值和最小值。
其实,有了求最值的算法,排序不也完成了一半?
想像一下桌子上摊开着牌,第一次我们从中换挑出大王放在手上,第二次我们挑出小王,然后是黑桃老K……黑桃Q,如此下去直到小A,手中的牌不也就已经排好次序了?
每次从中选出最大值或最小值,依此排成序,这就是选择排序法的过程描述。
不过,上述的过程有一点不合要求。
我们说过手中只能过一张牌。
因此,在程序实现时,我们找出一个最大值之后,就要把它放到数组中最末。
那数组中最末位置原来的值?
当然是把它放到最大值原来所在位置了。
为了再稍稍直观点,我们改为:
每次找的是最小值,找出后改为放到数组前头。
//选择排序(从小到大)
voidselect(intnum[],intcount)
{
inttmp;
intminIndex;//用于记住最小值的下标
for(inti=0;i {
minIndex=i;//每次都假设i所在位置的元素是最小的
for(intj=i+1;j {
if(num[minIndex] minIndex=j;
}
//把当前最小元素和前面第i个元素交换:
if(minIndex!
=i)
{
tmp=num[i];
num[i]=num[minIndex];
num[minIndex]=tmp;
}
}
}
同样是两层循环,内层循环非常类似于前面讲的求最值的的方法,重要的区别在于求最小值时,可以直接用N记下最小值,而我们这里是记下最小值元素的下标(位置)。
最后把这个位置上的元素值和前面第i个元素交换。
这就完成把挑出的最小值放到前面的过程。
关于如何调试,如何输出,和“冒泡”那一节一样。
大家一会儿再动手吧。
我先在纸上简要模拟一番,这样大家调试起来会更加心中有数。
2,5,1,4,3
第一遍:
找出最小值1(下标为2),将它和第一个元素(下标为0)进行交换,结果:
1,5,2,4,3
第二遍:
找出最小值2(下标为2),将它和第二个元素进行交换,结果:
1,2,5,4,3
第三遍:
1,2,3,4,5
同样,我们发现现在已经排好了,但程序的循环过程还得继续。
只是后面将是白忙活,什么也没变。
最后一遍是剩下一个1,没得比较,外层循环结束,选择排序完成。
但是,由于选择排序中内层循环完成的工作仅是找出其中的最小值,如果它空转了,只是意味着这些剩下元素中中的第一个元素正好就是最小值,并不意味剩下的元素已经有序。
所以我们也不就费心去加什么空转标志了。
同冒泡排序一样,选择排序的外层循环要进行n-1次,而内层为n/2次,所以总比较次数为:
(n-1)*n/2。
交换次数最好时为:
3*(n-1),最坏时为n^2/4+3*(n-1)。
18.2.4快速排序(选修)
排序的算法还有不少。
譬如“插入排序法”和“希尔排序法”。
前者有点像我们抓牌,抓到新牌,往手中已有牌的合适位置插入,最终牌都到手时,也排好序。
,后者是以它的创造者的名字命名。
它们都不是最快的算法。
我们不去说它了。
还是来说说(一般说来是)号称最快的算法吧。
“最快”是有代价的。
一个是其算法复杂,不直观,根本不是人脑所擅长的思维方式,因为它要求使用“递归”,我想就算是爱因斯坦在整理扑克时,估计也不爱用这种算法。
快速排序的基本思想是分割排序对象。
先选择一个值,作为“分割值”。
将所有大于该值的元素放到数组的一头,而所有小于该值的元素,放到数组的另一头。
这样就把数组按这个分割值划为两段。
接下来的事情是对这两段分别再进行前述的操作(找分割值,再划两段)……就这样一划二、二划四、四划八进行下去。
直到最每一段都只剩一个元素,排序完成。
在分段的过程中,每一个数组又是如何被归到某一段中去呢?
采用的也是巧妙的交换方法。
假设我们仍然是要进行“从小到大”的排序,那么当有了一个分割值以后,就应该把比分割值大的数扔到数组后头,而比分割值小的数扔到数组前头。
在快速排序法中,这个扔的过程是一种“对扔”。
即:
先找好前面的有哪个数需要扔到后面;再找好后面有哪个数需要扔到前头。
两个数都找好了,就把这两个数互相“扔”过去,其实还是交换两个数。
知道的人明白我是在说“快速排序”,不知道的人还当我是在说小布和老萨扔板砖哪?
所以,每一遍的分割过程是:
1、指定一个“分割值”。
2、从当前分段的数组前头开始往后找,找到下一个大于分割值的元素(准备扔到后头去);
3、从当前分段的数组后头开始往前找,找到下一个小于分割值的元素(准备扔到前头去);
4、交换2,3步找到两个元素
5、反复执行2,3,4,步;直到两端都已找不到要扔的元素。
这样,就把数组在逻辑上分为两段,前头的所有小于分割值是一段,后头所有大于分割值的是段,程序接下来递归调用快速排序的函数,分别把这两段都再次进行分割。
函数的递归调用也是我们曾经的“选修课”,如果你有些遗忘,可以回头加以复习。
每次的分割值是什么并没有太死的限定,但得在当前段数组元素最小值和最大值(含二者)之间,否则,比如元素是:
5,4,3,而分割值取的是6,就会分不出两段了。
我们下面做法比较通用:
就取当前段最中间那个元素的值,比如5,4,3中的4。
我们按照书写顺序,把数组前端称为“左端”,后端称为“右”端。
下面的代码中,left和L用来表示数组前端,而right和R表示后端。
voidquick(intarr,intleft,intright)
{
inttmp;
intL=left,R=right;
intV; //分割值。
V=arr[(L+R)/2]; //分割值取中间那个元素的值。
do
{
//找前端下一个小于分割值的元素:
while(L L++;
//找后端下一个大于分割值的元素:
while(R>left&&arr[R]>V)
R++;
if(L>R)//跑出当前段了,结束本段的“互扔”过程
break;
//开始互换,但L==R的情况说明是同一个元素,不用交换。
if(L {
tmp=arr[L];
arr[L]=arr[R];
arr[R]=tmp;
}
L++;
R--;
}
while(true);
//前面还可以分段,继续划分
//由于前面是在L>R情况下break出循环,所以R此时已经比L靠前,所以拿它
//来和是前头的left比较,以确定前面的元素是否超过1个。
if(left quick(left,R); //递归调用quick()
//后面还可以分段,继续划分
//同理,L此时其实比较靠后。
if(L>right)
quick(L,right); //递归调用quick()
}
快速排序的比较和交换的次数分别为:
n*log(n)和n*log(n)/6。
远远少于前面的两种排序方法。
.