排序模板

      简单地复习一下排序，虽然说常用的只有几种但还是把所有的排序都复习一下，所有算法的存在都有它的理由，也都承载着许多人的智慧，再理解一遍对OI的学习或许有一些启发作用。

pascal模板

冒泡排序

      最早学习的就是冒泡学习，原理最简单，当然速度也是最慢的，不过在一些特殊的题型中会有一些独有的作用，首先，是它的交换原理的应用，比如一些只能左右交换的数据就只可以用冒泡排序，题目就像熟知的车厢重组求步数，是非冒泡排序不可的。在冒泡的过程中，一定要注意记录当前循环是否发生交换，如果无则结束，也算一个剪枝吧：

i:=1

 repeat

   bo:=true;

   for  j：=1 to n-i do

   if a[j]<a[j+1] then

   begin

     t:=a[i];  a[i]:=a[j];  a[j]:=t;

     bo:=false;

   end;  

   inc(i);

 until bo; 

快速排序

      快排是最常用的一种算法，要掌握多关键字的快排和有主次之分的快排，用random来防止排序退化，然后注意一些小技巧即可。注意主程序里的randomize不要忘记：

procedure qsort(l,r:longint);

var

  i,j,k,mid:longint;

begin

  i:=l; j:=r;

  mid:=a[l+random(r-l+1)];

  repeat

    while a[i]<mid do inc(i);

    while a[j]>mid do dec(j);

    if i<=j then

    begin

      k:=a[i];

      a[i]:=a[j];

      a[j]:=k;

      inc(i); dec(j);

    end;

  until i>j;

  if i<r then qsort(i,r);

  if l<j then qsort(l,j);

end;

桶排序

      从原理上来说，桶排序是最快的一种排序，但是由于其内存开销太大了，所以从实用性上比较起来是比较弱的，但是这种思想还是很重要的，当然，数据规模不大时，桶排序还是很实用的。 

For i：=1 to m do b[i]:=0;   //m是数据范围

  For i:=1 to n do

  Begin

      Read(k);

      B[k]:=b[k]+1;

  End;

For i:=1 to m do

While b[i]>0 do begin

    Write(I,’ ‘);

    Dec(b[i]);

End;

插入排序

      这是一种比较慢的方法，主要思想是设置一个负无穷大的数，不断插入新的数，将后面的数后移一位，开始学习的时候受书上的误导，在原数组上操作，导致每插入一个数整个数组后移，奇慢，唉，尽信书不如无书啊，不过这个算法代码没多少复习必要，思想温习一下即可。还有熟练这种思想在有序链表上的运用，在hash表上还是比较常用的。

归并排序

      将多路有序数列合并，主要是比较麻烦，如果要可排序的话，可并堆会更优秀一些，但是这毕竟也可以和快排相媲美了

Procedure mergerort(s,t:longint);

Var

  M,I,j,k:longint;

Begin

  If s=t then exit;

  M:=(s+t)>>1;

  Mergesort(s,m);

  Mergesort(m+1,t);

  I:=s;

  J:=m+1;

  K:=s;

  While (i<=m)and(j<=t) do

  Begin

    If a[i]<a[j] then

       Begin

          R[k]:=a[i];

          Inc(i); inc(k);

       End

       Else begin

         R[k]:=a[j];

         Inc(j);

          Inc(k);

      End;

      While i<m do

      begin

         r[k]:=a[i]; inc(i); inc(k); 

      end;

      while j<=t do

      begin

        r[k]:=a[j]; inc(j); inc(k);

      end;

  for i：=s to t do

  remove(r[i],a[i],sizeof(r[i]));

end; 

基数排序

      基数排序比桶排略慢，但是内存消耗却比桶排序要节省许多，就是字符串处理比较麻烦，不过，也不失为一种比较好的算法：

var

  max,i,j,k,m,n:longint;

  x:array['0'..'9',1..100000] of ansistring;

  a:array[1..100000] of ansistring;

  l:array['0'..'9'] of longint;

  c:char;



begin

  readln(n);

  for i:=1 to n do

  begin

    readln(a[i]);

    if length(a[i])>max then max:=length(a[i]);

  end;

  for i:=1 to n do

  while length(a[i])<max do a[i]:='0'+a[i];

  for j:=max downto 1 do

  begin

    for c:='0' to '9' do l[c]:=0;

    for i:=1 to n do

    begin

      inc(l[a[i][j]]);

      x[a[i][j],l[a[i][j]]]:=a[i];

    end;

    m:=0;

    for c:='0' to '9' do

    for i:=1 to l[c] do

    begin

      inc(m);

      a[m]:=x[c,i];

    end;

  end;

  for i:=1 to n do

  begin

    for j:=1 to length(a[i]) do

    if a[i][j]<>'0' then

    begin

      for k:=j to length(a[i]) do

      write(a[i][k]);

      writeln;

      break;

    end;

  end;

end.

      单纯排序的似乎没有什么特别难的题目，但是经过组合，许多时候，巧妙地运用排序，比如优化二分或是优化搜索，可以提高程序效率，蒽，就这样吧，好好理解一下。