1.冒泡排序
从动画可看出冒泡排序十分慢，为o(n^2)
2.归并排序
归并排序(MergeSort)的基本思想是：将待排序文件看成为n个长度为1的有序子文件，把这些子文件两两归并，使得到「n/2」个长度为2的有序子文件；然后再把这「n/2」个有序文件的子文件两两归并，如此反复，直到最后得到一个长度为n的有序文件为止，这种排序方法成为二路归并排序。例如，有初始关键字序列：72,18,53,36,48,31,36，其二路归并排序过程如下所示。
n=7 [72] [18] [53] [36] [48] [31] [36]
一趟归并： [18 72] [36 53] [31 48] [36]
二趟归并： [18 36 53 72] [31 36 48]
三趟归并： [18 31 36 36 48 53 72]
时间复杂度为O(nlogn) 这是该算法中最好、最坏和平均的时间性能。
空间复杂度为 O(n)
3.快速排序
快速排序的时间主要耗费在划分操作上，对长度为k的区间进行划分，共需k-1次关键字的比较。
最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。时间复杂度为O(n*n)
在最好情况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：O(nlgn)
尽管快速排序的最坏时间为O(n2)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为O(nlgn)。
4.堆排序
堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，然后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有很多已经在前面的n-1次比较中已经做过，而树形选择排序恰好利用树形的特点保存了部分前面的比较结果，因此可以减少比较次数。对于n个关键字序列，最坏情况下每个节点需比较log2(n)次，因此其最坏情况下时间复杂度为nlogn。堆排序为不稳定排序，不适合记录较少的排序。
代码：
1.冒泡排序：
for i:=1 to n do
for j;=i+1 to n do
if a[i]<a[j] then
begin
t:=a[i];
a[i]:=a[j];
a[j]:=t;
end;
2.归并排序
type
arr=array[1..100]of
longint;
var
i,n:longint;
a,b:arr;
procedure hb(s,m,n,t:longint);
var i,l,j,k:longint;
begin
k:=s;
i:=s; j:=n;
while
(i<=m)and(j<=t) do
begin
if
a[i]<=a[j]
then
begin b[k]:=a[i];inc(i); end
else begin
b[k]:=a[j];inc(j); end;
inc(k);
end;
for
l:=i to m do begin b[k]:=a[l]; inc(k) end;
for
l:=j to n do begin b[k]:=a[l]; inc(k) end;
for
l:=s to t do a[l]:=b[l];
end;
procedure gb(s,t:longint);
var
mid:longint;
begin
if
s<t
then
begin
mid:=(s+t)div
2;
gb(s,mid);
gb(mid+1,t);
hb(s,mid,mid+1,t);
end;
end;
begin
readln(n);
for
i:=1 to n do
read(a[i]);
gb(1,n);
for
i:=1 to n do
write(a[i],‘
‘);
end.
3.快速排序
procedure cha(l,r:longint);
var i,j,mid,t:longint;
begin
i:=l;
j:=r;
mid:=a[(l+r) div 2];
while i<=j do
begin
while a[i]>mid do inc(i);
while a[j]<mid do dec(j);
if (i<=j) then
begin
t:=a[i];
a[i]:=a[j];
a[j]:=t;
inc(i);
dec(j);
end;
end;
if j>l then cha(l,j);
if i<r then cha(i,r);
end;
4.堆排序
var a:array[1..10000]of longint;
n,i:longint;
temp:longint;
procedure heap(i,x:longint);
var temp:longint;
begin
while i*2<x do
begin
i:=i*2;
if (a[i]<a[i+1]) and (i+1<=x) then inc(i);
if a[i]>a[i div 2] then
begin
temp:=a[i];
a[i]:=a[i div 2];
a[i div 2]:=temp;
end else exit;
end;
end;
begin
randomize;
read(n);
for i:=1 to n do a[i]:=random(217470000);
for i:=n div 2 downto 1 do heap(i,n);
for i:=n downto 2 do
begin
temp:=a[i];
a[i]:=a[1];
a[1]:=temp;
heap(1,i-1);
end;
for i:=1 to n do writeln(a[i]);
end.
版权声明：本文为博主原创文章，未经博主允许不得转载。