排序算法演示
算法原理
下列动图来自五分钟学算法，演示了快速排序算法的原理和步骤。
步骤:
从数组中选个基准值
将数组中大于基准值的放同一边、小于基准值的放另一边，基准值位于中间位置
递归的对分列两边的数组再排序
代码实现
function
quickSort($arr)
{
$len
=
count($arr);
if
($len
<=
1)
{
return
$arr;
}
$v
=
$arr[0];
$low
=
$up
=
array();
for
($i
=
1;
$i
<
$len;
++$i)
{
if
($arr[$i]
>
$v)
{
$up[]
=
$arr[$i];
}
else
{
$low[]
=
$arr[$i];
}
}
$low
=
quickSort($low);
$up
=
quickSort($up);
return
array_merge($low,
array($v),
$up);
}
测试代码:
$startTime
=
microtime(1);
$arr
=
range(1,
10);
shuffle($arr);
echo
"before
sort:
",
implode(',
',
$arr),
"\n";
$sortArr
=
quickSort($arr);
echo
"after
sort:
",
implode(',
',
$sortArr),
"\n";
echo
"use
time:
",
microtime(1)
-
$startTime,
"s\n";
测试结果:
before
sort:
1,
7,
10,
9,
6,
3,
2,
5,
4,
8
after
sort:
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
use
time:
0.0009009838104248s
时间复杂度
快速排序的时间复杂度在最坏情况下是O(N2)，平均的时间复杂度是O(N*lgN)。
这句话很好理解：假设被排序的数列中有N个数。遍历一次的时间复杂度是O(N)，需要遍历多少次呢？至少lg(N+1)次，最多N次。
1)
为什么最少是lg(N+1)次？快速排序是采用的分治法进行遍历的，我们将它看作一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是lg(N+1)。因此，快速排序的遍历次数最少是lg(N+1)次。
2)
为什么最多是N次？这个应该非常简单，还是将快速排序看作一棵二叉树，它的深度最大是N。因此，快读排序的遍历次数最多是N次。
您可能感兴趣的文章:PHP快速排序算法实例分析PHP四种排序算法实现及效率分析【冒泡排序,插入排序,选择排序和快速排序】PHP排序算法之快速排序(Quick
Sort)及其优化算法详解PHP递归实现快速排序的方法示例php
二维数组快速排序算法的实现代码PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】PHP快速排序quicksort实例详解
‘贰’ 跪求数据结构：堆排序算法演示
《C算法》——堆排序
堆排序(Heap Sort)只需要一个记录大小的辅助空间
堆排序在最坏的情况下，其时间复杂度为O(nlog n),相对于快速排序来说，这是堆的最大优点。
堆是一棵完全二叉树，且树中不存在大于（小于）父节点的节点。
堆中的第i个元素大于或等于第2i个元素和第2i+1个元素。
自底向上的堆化
fixUp(Item* a, int k)
...{
while(k>1 && less(a[k/2], a[k]))
...{
exch(a[k], a[k/2]);
k = k / 2; //向上找到父结点
}
}
--------------------------------------------------------------------------------
自顶向下的堆化 fixDown(Item* a, int k, int N)
...{
int j;
while(2*k <= N)
...{
j = 2 * k;
if(j<N && less(a[j], a[j+1])) j++; //选择两个孩子中较大者，与a[k]比较
if(!less(a[k], a[j])) break; //局部满足堆条件，立即退出
exch(a[k], a[j]); //否则，交换
k = j;
}
}
--------------------------------------------------------------------------------
堆排序 void heapsort(Item* a, int l, int r)
...{
int k, N = r-l+1; //N为待排元素的个数
for(k = N/2; k >= 1; k--) //建堆，从第一个非叶子节点开始
fixDown(a, k, N); //自顶向下的堆化
while(N > 1)
...{
exch(a[l], a[l+N-1]); //把第一个元素（最大）和最后一个元素交换
fixDown(a, 1, --N); //再自顶向下堆化
}
}
‘叁’ 如何制作排序算法演示程序
首先你要知道怎么排序......排序的方式是归并 快排还是冒泡倍增...........然后接下来就都是一些操作上的细节了...............这个界面呃 目测可以用VB做吧......
‘肆’ 快速排序算法的排序演示
假设用户输入了如下数组： 下标 0 1 2 3 4 5 数据 6 2 7 3 8 9 创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。
我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较： 下标 0 1 2 34 5 数据 3 2 7 6 8 9 i=0 j=3 k=6
接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表： 下标 0 1 2 3 4 5 数据 3 2 6 7 8 9 i=2 j=3 k=6
称上面两次比较为一个循环。
接着，再递减变量j，不断重复进行上面的循环比较。
在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大： 下标 0 1 2 3 4 5 数据 3 2 6 7 8 9 如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。
然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。
注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。 在c++中可以用函数qsort（）可以直接为数组进行排序。
用 法:
void qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));
参数：1 待排序数组首地址2 数组中待排序元素数量3 各元素的占用空间大小4 指向函数的指针，用于确定排序的顺序
‘伍’ C语言实现七种排序算法的演示代码是什么
（1）“冒泡法”
冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,若a[0]>a[i]，则交换它们，一直比较到a[n]。同理对a[1],a[2],...a[n-1]处理，即完成排序。下面列出其代码：
void
bubble(int
*a,int
n)
/*定义两个参数：数组首地址与数组大小*/
{
int
i,j,temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
/*注意循环的上下限*/
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
冒泡法原理简单，但其缺点是交换次数多，效率低。
下面介绍一种源自冒泡法但更有效率的方法“选择法”。
（2）“选择法”
选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。
void
choise(int
*a,int
n)
{
int
i,j,k,temp;
for(i=0;i<n-1;i++)
{
k=i;
/*给记号赋值*/
for(j=i+1;j<n;j++)
if(a[k]>a[j])
k=j;
/*是k总是指向最小元素*/
if(i!=k)
{
/*当k!=i是才交换，否则a[i]即为最小*/
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。
（3）“快速法”
快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).
它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。下面分析其代码：
void
quick(int
*a,int
i,int
j)
{
int
m,n,temp;
int
k;
m=i;
n=j;
k=a[(i+j)/2];
/*选取的参照*/
do
{
while(a[m]<k&&m<j)
m++;
/*
从左到右找比k大的元素*/
while(a[n]>k&&n>i)
n--;
/*
从右到左找比k小的元素*/
if(m<=n)
{
/*若找到且满足条件，则交换*/
temp=a[m];
a[m]=a[n];
a[n]=temp;
m++;
n--;
}
}while(m<=n);
if(m<j)
quick(a,m,j);
/*运用递归*/
if(n>i)
quick(a,i,n);
}
（4）“插入法”
插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。
void
insert(int
*a,int
n)
{
int
i,j,temp;
for(i=1;i<n;i++)
{
temp=a[i];
/*temp为要插入的元素*/
j=i-1;
while(j>=0&&temp<a[j])
{
/*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
/*插入*/
}
}
（5）“shell法”
shell法是一个叫
shell
的美国人与1969年发明的。它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分析其代码：
void
shell(int
*a,int
n)
{
int
i,j,k,x;
k=n/2;
/*间距值*/
while(k>=1)
{
for(i=k;i<n;i++)
{
x=a[i];
j=i-k;
while(j>=0&&x<a[j])
{
a[j+k]=a[j];
j-=k;
}
a[j+k]=x;
}
k/=2;
/*缩小间距值*/
}
}
上面我们已经对几种排序法作了介绍，现在让我们写个主函数检验一下。
#include<stdio.h>
/*别偷懒，下面的"..."代表函数体，自己加上去哦！*/
void
bubble(int
*a,int
n)
{
...
}
void
choise(int
*a,int
n)
{
...
}
void
quick(int
*a,int
i,int
j)
{
...
}
void
insert(int
*a,int
n)
{
...
}
void
shell(int
*a,int
n)
{
...
}
/*为了打印方便，我们写一个print吧。*/[code]
void
print(int
*a,int
n)
{
int
i;
for(i=0;i<n;i++)
printf("%5d",a[i]);
printf("\n");
}
main()
{
/*为了公平，我们给每个函数定义一个相同数组*/
int
a1[]={13,0,5,8,1,7,21,50,9,2};
int
a2[]={13,0,5,8,1,7,21,50,9,2};
int
a3[]={13,0,5,8,1,7,21,50,9,2};
int
a4[]={13,0,5,8,1,7,21,50,9,2};
int
a5[]={13,0,5,8,1,7,21,50,9,2};
printf("the
original
list:");
print(a1,10);
printf("according
to
bubble:");
bubble(a1,10);
print(a1,10);
printf("according
to
choise:");
choise(a2,10);
print(a2,10);
printf("according
to
quick:");
quick(a3,0,9);
print(a3,10);
printf("according
to
insert:");
insert(a4,10);
print(a4,10);
printf("according
to
shell:");
shell(a5,10);
print(a5,10);
}
‘陆’ 用VB实现常用排序算法的动态演示
http://blog.ytcnc.net/UploadFiles/2009-11/1127277865.rar
原来是老外写的七种排序算法的演示，我把界面上的英文换成中文了
‘柒’ 用Javascript写排序算法的动画演示
1.让JavaScript暂停下来，慢下来。
JavaScript排序是很快的，要我们肉眼能看到它的实现过程，我首先想到的是让排序慢下来。 排序的每一个循环都让它停300ms然后再继续进行。 怎么样才能停下来呢。查了一下JavaScript貌似没有sleep()这样的函数。暂停做不到，但是可以想办法让实现跟暂停差不多的效果。比如在循环里做一些无关的事情 。
首先尝试了让while(true)来一直执行一个空操作。执行一段时间再回到排序逻辑。代码大致是这样：
for (var i = 0; i < 3; i++) {
document.writeln(i); //DOM操作
var now = new Date().getTime();
while(new Date().getTime() - now < 3000){}
}
慢是慢下来了。不过太耗资源，排序进行过程中dom并不会有任何改变，直到排序结束， DOM会变成排序好之后的样子。 但是如果设置断点一步步执行的时候 又可以看到一步步的排序变化。估计是因为这个操作太耗资源导致浏览器下达了一个DOM操作的命令但是一直腾不出资源来进行DOM操作。所以真正DOM操作的时候在js代码执行结束之后。
所以让JavaScript排序慢来来还是没有实现。
另一种让JavaScript暂停下来的思路：
写这个文章的时候又想到一种方法来让JavaScript停下来。 那就是AJAX的同步请求，以及超时操作。 也就是在要停下来的地方放一个AJAX请求，同步请求， 然后设置超时。超时的时间就是我们要暂停的时间。为了避免在到达超时请求之前服务 器就返回了我们的AJAX请求。可以在服务端运行类似 sleep()的程序 。从而保证AJAX不会返回。直接超时然后返回到我们的循环。不过这只是个设想。有兴趣的可以去尝试一下。
2.闭包和定时器。 这种思路不需要让排序过程慢下来。而是使用闭包缓存排序过程中数组的变化。然后使用setTimeout来确定展示每一个数组状态的顺序。在排序循环中放入类似下面的代码。
(function(){
var theArr = arr.slice();//当前数组状态的备份
setTimeout(function(){
bubbleSortDom(theArr);//排序的DOM操作。
},500*timeCount);
timeCount++;//定时器的顺序。
})();
不过后来发现这样子写的话代码量会比较大，逻辑有修改的话要修改的地方会有点多。局限性很多，比如要实现排序动画加快或减慢操作几乎是很困难的。所以还要另想办法。
3.缓存排序中的数组状态。
也就是在排序过程中。将数组的每一轮循环的状态保存到一个数组。然后再用这个数组依次将排序状态保存下来。 只需要在排序中加入一句就行。
this.pushHis(arr.slice(),i-1,j,k,temp);
这样就只需要一个setInterval()就可以了。并且可以很方便的实现动画的加快与减慢。逻辑也比较好理解 。
问题二：如何实现JavaScript排序动画的加快与减慢。
我们问题一使用的第三种方法。 得到一个保存了每一步排序状态的数组arr。 然后我们可以使用一个setInterval()定时器一步步展现排序状态。 如果要加快速度或减慢速度。就clearInterval()，修改定时器的执行间隔，重新setInterval()，从前一个定时器执行到数组中的位置开始执行。
问题三：对于使用递归实现的数组怎么办？ 不是在原数组上进行操作的怎么办？
使用递归实现的排序。 可能并没有在一个数组上进行操作，只是最后返回一个排序好的数组出来。那么我们要如何获得排序中的数组的完整状态呢。
比如快速排序。
最开始不考虑动画，我的实现是这样的：
function quickSort(arr){
var len = arr.length,leftArr=[],rightArr=[],tag;
if(len<2){
return arr;
}
tag = arr[0];
for(i=1;i<len;i++){
if(arr[i]<=tag){
leftArr.push(arr[i])
}else{
rightArr.push(arr[i]);
}
}
return quickSort(leftArr).concat(tag,quickSort(rightArr));
}
然后为了考虑动画，我改写了它的逻辑，让它在同一个数组上进行了实现。 其实是在递归的时候传入了当前的的子数组在原数组中的起始位置。从而在原数组上进行了操作。
用了两种方法来实现方式。在排序逻辑上略有不同。
第一种是先跟远处的对比。遇到比自己小的放到自己前面去。循环序号+1。比自己大的放到当前排序子数组的最后面去，循环序号不变。直到排列完成。
这种方法的缺点是即使是一个有序数组。它也会重新排。
第二种方法是 除了标记位，再设置一个对比位。 遇到比自己小的，放到前面去，标记位的位置+1，标记位与对比位之间所有的往后面移动一个位置。
遇到比自己大的。标记位不变，对比位+1。
这种方法的缺点是对数组进行的操作太多。优点是对有序数组不会再排。
方式一：
function quickSort(arr,a,b,qArr){
var len = arr.length,leftArr=[],rightArr=[],tag,i,k,len_l,len_r,lb,ra,temp;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}
if((len == 2 && arr[0] == arr[1])||len<2){
return arr;
}
tag = qArr[a];
for (i = 1; i < len;) {
if(qArr[a+i]<=tag){
leftArr.push(qArr[a+i]);
qArr[a+i-1] = qArr[a+i];
qArr[a+i] = tag;
k = a+i;
i++;
}else{
if(leftArr.length+rightArr.length == len-1){
break;
}
temp = qArr[a+i];
qArr[a+i] = qArr[b-rightArr.length];
qArr[b-rightArr.length] = temp;
rightArr.push(temp);
k = a+i-1;
}
this.pushHis(qArr.slice(),a,b,k);
}
len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}
if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr
}
方式二：
function quickSort2(arr,a,b,qArr){
var len = arr.length,leftArr=[],rightArr=[],tag,i,j,k,temp,len_l,len_r,lb,ra;
if(a == undefined && b == undefined){
a = 0; b= arr.length-1;//初始化起始位置。
}
if(qArr == undefined){
qArr = arr.slice();
}
if(len<2){
return arr;
}
if(len == 2 && arr[0] == arr[1]){
return arr;
}
tag = qArr[a];
for (i = 1,k = 0; i < len;) {
if(qArr[a+i]>=tag){
rightArr.push(qArr[a+i]);
i++;
}else{
temp = qArr[a+i];
for(j = a+i;j>a+k;j--){
qArr[j] = qArr[j-1];
// this.pushHis(qArr.slice(),a,b,a+k);
}
qArr[a+k] = temp;
leftArr.push(temp);
k++;
i++;
}
this.pushHis(qArr.slice(),a,b,a+k,i-1);
}
len_l = leftArr.length;
len_r = rightArr.length;
if(len_l== 0){
lb = a;
}else{
lb = a+len_l -1;
this.sort(leftArr,a,lb,qArr);
}
if(len_r == 0){
ra = b;
}else{
ra = b + 1 - len_r;
this.sort(rightArr,ra,b,qArr)
}
return qArr;
}
具体的不同下面会有动画演示。
问题四：动画的流畅。
排序动画的DOM操作是很多的很快的。这里我做的优化只是让每一个排序步骤只涉及一个DOM操作。 全部由JavaScript拼接好，一次替换。类似下面的代码。
效果图：
主要实现了：
冒泡排序JavaScript动画演示
插入排序JavaScript动画演示
选择排序JavaScript动画演示
快速排序JavaScript动画演示
归并排序JavaScript动画演示
希尔排序JavaScript动画演示
‘捌’ 各种内部排序算法演示用C语言实现 排序过程中用动态的显示
#include<stdio.h>
#defineMAX1000
intquick(int*a,intl,intr,intlength)
{
intcounter=0,i;
a[0]=a[l];
while(l<r)
{
while(l<r&&a[0]<=a[r])
r--;
a[l]=a[r];
while(l<r&&a[0]>a[l])
l++;
a[r]=a[l];
}
a[l]=a[0];
printf("Step%d:",++counter);
for(i=1;i<length;i++)
printf("%d",a[i]);
printf("%d ",a[length]);
returnl;
}
voidquicksort(int*a,intl,intr,intlength)//快速排序
{
intp;
if(l<r)
{
p=quick(a,l,r,length);
quicksort(a,l,p-1,length);
quicksort(a,p+1,r,length);
}
}
voidheap(int*a,intlength,inti)
{
ints=i,t;
if(2*i<=length&&a[2*i]>a[s])
s=2*i;
if(2*i+1<=length&&a[2*i+1]>a[s])
s=2*i+1;
if(s!=i)
{
t=a[i];
a[i]=a[s];
a[s]=t;
heap(a,length,s);
}
}
voidheapsort(int*a,intlength)//堆排序
{
inti,t,counter=0,k=length;
for(i=length/2;i>=1;i--)
heap(a,length,i);
while(length>1)
{
t=a[1];
a[1]=a[length];
a[length]=t;
heap(a,--length,1);
printf("Step%d:",++counter);
for(i=1;i<k;i++)
printf("%d",a[i]);
printf("%d ",a[k]);
}
}
voidinsertsort(int*a,intlength)//插入排序
{
inti,j,t,k,counter=0;
if(length==1)
{
printf("Step%d:%d ",++counter,a[1]);
return;
}
for(i=2;i<=length;i++)
{
t=a[i];
for(j=i-1;j>0&&a[j]>=t;j--);
for(k=i-1;k>=j+1;k--)
a[k+1]=a[k];
a[k+1]=t;
printf("Step%d:",++counter);
for(k=1;k<length;k++)
printf("%d",a[k]);
printf("%d ",a[length]);
}
}
intmain()
{
intn,i;
inta[MAX];
while(scanf("%d",&n)&&n)
{
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
quicksort(a,1,n,n);
}
return0;
}
‘玖’ 几种排序算法的演示，要求给出从初始开始时的每一趟的变化情况，并对各种排序算法的排序性能做分析和比较
//冒泡排序
#include <iostream>
using namespace std;
void print(int* a, int n){
for(int i=0; i<n; i++){
cout << a[i] << ' ';
}
cout << endl;
}
void sort(int* a, int n){
for(int i=0; i<n-1; ++i){//进行n-1次排序
bool f = true;
for(int j=0; j<n-1-i; j++){//两两相比
if(a[j]>a[j+1]){
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
f = false;
}
}
cout << "第" << i << "次:";
print(a, 10);
if(f)break;
}
}
int main()
{
int a[10] = {2,3,4,9,0,1,8,7,6,5};
cout << "排序前:";
print(a, 10);
sort(a, 10);
cout << "排序后:";
print(a, 10);
}
//选择排序
#include <iostream>
#include <algorithm>
using namespace std;
void print(int* a, int n){
for(int i=0; i<n; i++){
cout << a[i] << ' ';
}
cout << endl;
}
void sort(int* a, int n){
for(int i=0; i<n-1; i++){
int k = i;//假设i是最小的数的下标
for(int j=i+1; j<n; j++){
if(a[j]<a[k]) k = j;
}
if(i!=k) swap(a[i], a[k]);
cout << "第" << i << "次:";
print(a, 10);
}
}
int main()
{
int a[10] = {2,3,4,9,0,1,8,7,6,5};
cout << "排序前:";
print(a, 10);
sort(a, 10);
cout << "排序后:";
print(a, 10);
}
//快速排序
#include <iostream>
#include <algorithm>
using namespace std;
void print(int* a, int n){
for(int i=0; i<n; i++){
cout << a[i] << ' ';
}
cout << endl;
}
void sort(int* a, int n){
//当分组中的数据是1个或0个时，分组结束
if(n<=1)return;
//将数据分成两个组
int L = 0;
int R = n-1;
while(L<R){
while(L<R&&a[L]<=a[R]) R--;
swap(a[L], a[R]);
while(L<R&&a[L]<=a[R]) L++;
swap(a[L], a[R]);
}
//对左边的组再进行分组
sort(a, L);
//对右边的组再进行分组
sort(a+L+1,n-L-1);
}
int main()
{
int a[10] = {2,3,4,9,0,1,8,7,6,5};
cout << "排序前:";
print(a, 10);
sort(a, 10);
cout << "排序后:";
print(a, 10);
}
//插入排序
#include <iostream>
#include <algorithm>
using namespace std;
void print(int* a, int n){
for(int i=0; i<n; i++){
cout << a[i] << ' ';
}
cout << endl;
}
void sort(int* a, int n){
for(int i=1; i<n; ++i){
int t = a[i];//要插入的元素
int j = i;//要插入的位置
for( ; j>0&&a[j-1]>t; --j){
a[j] = a[j-1];
}
a[j] = t;
cout << "第" << i << "次:";
print(a, 10);
}
}
int main()
{
int a[10] = {2,3,4,9,0,1,8,7,6,5};
cout << "排序前:";
print(a, 10);
sort(a, 10);
cout << "排序后:";
print(a, 10);
}
‘拾’ 如何编写冒泡排序算法的演示程序
#include<stdio.h>
#define MAX_N 1024 /*存储大小为1024*/
void bubsort(int a[],int n)/*冒泡排序*/
{
int i,j,tmp;
for(i=0;i<n;i++)
for(j=n-1;j>i;j--)
if(a[j]<a[j-1])/*如果a[j]比前面a[j-1]的小，则交换向上浮*/
{/*交换数组a[j]和a[j-1]*/
tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
}
}
int main(void)
{
int i,input,N;
int arr[MAX_N];/*arr为int线性数组*/
puts("请输入排序数组的大小N:");
scanf("%d",&N);/*读入N*/
printf("请输入要排序的%d个数:\n",N);
for(i=0;i<N;i++)/*输入*/
scanf("%d",&arr[i]);
bubsort(arr,N);/*排序函数*/
puts("排序之后....");
for(i=0;i<N-1;i++)/*输出*/
printf("%d ",arr[i]);
printf("%d\n",arr[N-1]);
return 0;
}