五、排序

标签：

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)

快速排序的时间主要耗费在划分操作上，对长度为k的区间进行划分，共需k-1次关键字的比较。

最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。时间复杂度为O(n*n)

在最好情况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：O(nlgn)

尽管快速排序的最坏时间为O(n²)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为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.

五、排序

标签：

原文地址：http://blog.csdn.net/boyxiejunboy/article/details/46879603