Pascal 排序算法

Pascal 排序

 

排序

排序就是将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程。排序问题是一个十分重要的问题，并且排序的方法有很多种:

例子:输入20个数，将它们按照从高到低的次序排列以后输出。

方法一:选择排序

选择排序的基本思想:首先从要进行排序的数中选择最大的一个数，将它放在第一个位置，然后从剩下的数中选择最大的放在第二个位置，如此继续，直到最后剩下的两个数中选出较大的数放在倒数第二个位置，剩下的一个数放在最后完成排序。

具体操作:对需要排序的数据序列进行n-1遍的处理，第1遍处理是将L[2..n]中每一个元素与L[1]比较，最大者与L[1]交换位置，第2遍处理是将L[3..n]中每一个元素与L[2]比较，最大者与L[2]交换位置，......，第i遍处理是将L[i+1..n]中每一个元素与L[i]比较，最大者与L[i]交换位置。

算法:1、输入20个数到数组a中;

2、用外循环确定每一个数，需要循环19次;(For i:=1 to 19 do)

3、用内循环实现确定数与后面所有数的比较和交换;For j:=i+1 to 20 do

4、输出结果。                                     If a[i]<a[j]

为了理解，我们以6个数为例来进行说明:

a[1]     a[2]     a[3]     a[4]     a[5]     a[6]

4        5        7        1        2        3

5        4        7        1        2        3

7        4        5        1        2        3

7        4        5        1        2        3

7        4        5        1        2        3

7        4        5        1        2        3  第一趟结束

7        5        4        1        2        3

7        5        4        1        2        3

7        5        4        1        2        3

7        5        4        1        2        3  第二趟结束

7        5        4        1        2        3

7        5        4        1        2        3

7        5        4        1        2        3  第三趟结束

7        5        4        1        2        3

7        5        4        1        2        3  第四趟结束

7        5        4        1        2        3  第五趟结束

参考程序如下:

Program example(input,output);

Var

a:array[1..20] of integer;

temp: integer;

i,j:integer;

Begin

For i:=1 to 20 do  {读入20个元素}

read(a[i]);

For i:=1 to 19 do  {从第一个到倒数第二个依次确定每个数 }

For j:=i+1 to 20 do  {确定的数与它后面所有的数进行比较}

If a[i]<a[j]

Then  Begin

temp:= a[i];

a[i]:= a[j];

a[j]:=temp

End;

For i:=1 to 20 do   {输出排序后的结果}

Begin

write(a[i]:5);

If i mod 5=0    {控制每行输出5个数据}

Then writeln

End;

End.

上面的程序每次交换两个元素需要执行3个语句，过多的交换必定要花费许多时间，我们做一下改进，就是在内循环中先找出最大值元素的下标，在内循环结束时才考虑是否要交换。改进的选择程序如下:

Program example(input,output);

Var

a:array[1..20] of integer;

temp: integer;

i,j,k:integer;     {添加了一个中间存放下标的变量k}

Begin

For i:=1 to 20 do  {读入20个元素}

read(a[i]);

For i:=1 to 19 do  {从第一个到倒数第二个依次确定每个数 }

Begin

k:=i;

For j:=i+1 to 20 do  {比较之后仅将下标交换给变量k}

If a[i]<a[j]

Then k:=j;

If i<>k

Then  Begin

temp:= a[i];

a[i]:= a[k];

a[k]:=temp

End;

End;

For i:=1 to 20 do   {输出排序后的结果}

write(a[i]);

End.

例子:输入20个数，将它们按照从高到低的次序排列以后输出。

方法二:冒泡排序

冒泡排序的基本思想:依次比较相邻的两个数，将较大的数放在前面，较小的数放在后面。即首先比较第1个数和第2个数，将大的放在前面小的放在后面，然后比较第2个数和第3个数，仍将大的放在前面小的放在后面，如此继续，直到比较最后两个数，大的放在前面小的放在后面，此时第一趟结束，在最后的数必定是最小的数。重复以上步骤，只是最后不用比较最后两个数，这一趟比第一趟少了一步，依次继续下去，直到最后一趟，只比较第一对数，大的放在前面小的放在后面，从而完成排序。

由于在排序过程中总是大数往前放，小数往后放，相当于气泡往上升，所以叫冒泡排序。

算法:

1、输入20个数到数组a中;

2、用外循环实现将最小的数置后，需要循环19次;(For i:=1 to 19 do)

3、用内循环实现相邻两位数的置换; For j:=1 to 20-i do

4、输出结果。                        If a[j]<a[j+1]

为了理解，我们以6个数为例来进行说明:

a[1]     a[2]     a[3]     a[4]     a[5]     a[6]

4        5        7        1        2        3

5        4        7        1        2        3

5        7        4        1        2        3

5        7        4        1        2        3

5        7        4        2        1        3

5        7        4        2        3        1  第一趟结束

7        5        4        2        3        1

7        5        4        2        3        1

7        5        4        2        3        1

7        5        4        3        2        1  第二趟结束

7        5        4        3        2        1

7        5        4        3        2        1

7        5        4        3        2        1  第三趟结束

7        5        4        3        2        1

7        5        4        3        2        1  第四趟结束

7        5        4        3        2        1  第五趟结束

参考程序如下:

Program example(input,output);

Var

a:array[1..20] of integer;

temp: integer;

i,j:integer;

Begin

For i:=1 to 20 do  {读入20个元素}

read(a[i]);

For i:=1 to 19 do  {从最后一个到第二个依次确定每个数 }

For j:=1 to 20-i do  {实现相邻两位数的置换}

If a[j]<a[j+1]

Then Begin

temp:= a[j];

a[j]:= a[j+1];

a[j+1]:=temp

End;

For i:=1 to 20 do   {输出排序后的结果}

Begin

write(a[i]:4);

If i mod 5=0

Then writeln

End;

End. 

上面的这三种程序的比较次数都是190次，因为

19+18+17+…+1=((19+1)/2)*19=190次

在上面冒泡排序的例子中，我们可以看到，在比较完第二趟之后，数组已经排好序，但计算机并不知道，它还要继续进行第三、第四、第五趟。我们可以做一下改进，如果在某一趟的比较中没有发现任何数据交换，则知道已排好序，可以不用再进行比较了，因此第三趟还需要进行，第四趟、第五趟比较则是不必要的。

最完美的是这样一种情况，如果读入的数是排好序的，则只需要进行一趟比较（19次）就可以了，而不用进行19趟（190次）比较了。

为了标志在比较的过程中是否发生了数据交换，我们可以定义一个布尔型的变量flag，以此来判断是否有数据交换。循环中先把flag置为true，如果有数据交换，在交换之后将flag置为false，最后判断如果flag仍为true，则说明已经排好顺序，循环退出，输出结果。由于不确定到底循环多少次，我们可以使用repeat语句。

改进的选择程序如下:

Program example(input,output);

Var

a:array[1..20] of integer;

temp: integer;

i,j:integer;

flag:boolean;   {添加了一个标志变量flag}

Begin

For i:=1 to 20 do  {读入20个元素}

read(a[i]);

i:=1;

Repeat  {不确定需要循环多少次,所以用Repeat语句}

Flag:=true;

For j:=1 to 20-i do  {实现相邻两位数的置换}

If a[j]<a[j+1]

Then Begin

temp:= a[j];

a[j]:= a[j+1];

a[j+1]:=temp

flag:=false

End;

i:=i+1;

Until flag;

For i:=1 to 20 do   {输出排序后的结果}

write(a[i]);

End;

End.

例子:输入20个数，将它们按照从高到低的次序排列以后输出。

方法三:插入排序

插入排序的基本思想:从第2个数开始取出,从其前一个元素向前依次和它比较,如果遇到比它小的,就将小的数据向后移动一个位置,从而插入到它前面已经排好序的数列中去。如此继续，每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序;直到待排序数据元素全部插入完为止。

比如:

a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

5    7    3    4    6    1    9    8    2   取出第2个数

7    5    3    4    6    1    9    8    2   取出第3个数

7    5    3    4    6    1    9    8    2   取出第4个数

7    5    4    3    6    1    9    8    2   取出第5个数

7    6    5    4    3    1    9    8    2   取出第6个数

7    6    5    4    3    1    9    8    2   取出第7个数

9    7    6    5    4    3    1    8    2   取出第8个数

9    8    7    6    5    4    3    1    2   取出第9个数

9    8    7    6    5    4    3    2    1

参考程序如下:

Program example(input,output);

Var

a:array[1..20] of integer;

t: integer;  {定义一个用于放置取出元素的变量}

i,j:integer;

Begin

For i:=1 to 20 do  {读入20个元素}

read(a[i]);

For i:=2 to 20 do  {从第二个数开始取出 }

Begin

t:=a[i];

j:=i-1;

while (j>0) and (a[j]<t) do  {依次将它前面比它小的数向后移动一个位置}

    begin            问题:条件可不可以写成(a[j]<t) and (j>0)，为什么？

a[j+1]:=a[j];

      j:=j-1;

    end;

a[j+1]:=t; {遇到不比它小的数之后，将取出的数据放置在此数之后}

end;

For i:=1 to 20 do   {输出排序后的结果}

write(a[i]:5);

End.

以上三种方法比较简单，属于简单排序。下面介绍一种比较复杂的高级排序方法:

例子:输入20个数，将它们按照从高到低的次序排列以后输出。

方法四:快速排序算法

快速排序是对冒泡排序的一种改进。

它的基本思想是:通过一趟排序将要排序的数据分割成独立的左右两部分，其中一部分的所有数据都比另外一部分的所有数据要小，而另一部分的所有数据都比前一部分的所有数据要大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，直到每一个待处理的序列的长度为1, 处理结束。

   具体操作:假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。

比如:              A[1]   A[2]   A[3]   A[4]   A[5]   A[6]   A[7]              

                    49    38     65     27     76     13     97

一趟快速排序之后    97    76     65     49     13     27     38

一趟快速排序的算法是:

  1）设置两个变量I、J，排序开始的时候I:=1，J:=N;

  2）以第一个数组元素作为关键数据，赋值给X，即X:=A[1];

  3）从J开始向前搜索，即由后开始向前搜索（J:=J-1），找到第一个大于X的值，两者交换;

  4）从I开始向后搜索，即由前开始向后搜索（I:=I+1），找到第一个小于X的值，两者交换;

  5）、重复第3、4步，直到I=J;

  例如:待排序的数组A的值分别是:（初始关键数据X:=49）

A[1]   A[2]   A[3]   A[4]   A[5]   A[6]   A[7]              

  49    38     65     27     76     13     97 从后搜，交换前I=1; J=7;交换后I=2 ;J=7

  97    38     65     27     76     13     49 从前搜，交换前I=2; J=7;交换后I=2 ;J=6     

  97    49     65     27     76     13     38 从后搜，交换前I=2; J=6;交换后I=3 ;J=5

  97    76     65     13     49     27     38 从前搜，交换前I=3; J=5;交换后I=4 ;J=5

  97    76     65     49     13     27     38 从后搜，当I=4 ;J=4 结束

     经过一趟快速排序之后的结果是:97   76   65   49   13   27   38，即所有大于49的数全部在49的前面，所有小于49的数全部在49的后面。     

一趟快速排序的程序段:

x:=a[i];

repeat

        while (a[j]<x) and (j>i) do {从后往前搜索比x大的数}

j:=j-1;

        if j>i then  {找到比x大的数后和前面的数进行交换}

begin

w:=a[i];

a[i]:=a[j];

a[j]:=w;

i:=i+1; {交换之后i的值应该增加，定位到后一个}

end;

        while (a[i]>x) and (i<j) do {从前往后搜索比x小的数}

i:=i+1;

        if i<j then

begin

w:=a[j];

a[j]:=a[i];

a[i]:=w;

j:=j-1; {交换之后j的值应该减少，定位到前一个}

end

      until i=j;

整个快速排序过程的实现:

利用分治思想（即大化小的策略）可进一步对分开的两组数据再次分别进行快速排序，照此继续，直到分组对象只有一个数据为止。

我们可以将一趟快速排序写成过程，快速排序就是递归调用此过程。

在上面的例子中，以49为中点分割这个数据序列，然后分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图所示: 

初始状态                    {49    38    65    97    76    13    27}   

进行一次快速排序之后划分为   {97    76    65}   49    {13   27    38}

分别对前后两部分进行快速排序 97     {76   65}   49    {38   27}    13

                             结束   {76}  {65}        {38}   {27 }  结束

                                    结束  结束       结束  结束

完整的过程:

procedure quicksort(var a:array; s,e:integer);

var i,j,x,w:integer;

    begin

i:=s;

j:=e;

x:=a[i];

repeat

        while (a[j]<x) and (j>i) do {从后往前搜索比x大的数}

j:=j-1;

        if j>i then  {找到比x大的数后和前面的数进行交换}

begin

w:=a[i];

a[i]:=a[j];

a[j]:=w;

i:=i+1; {交换之后i的值应该增加，定位到后一个}

end;

        while (a[i]>x) and (i<j) do {从前往后搜索比x小的数}

i:=i+1;

        if i<j then

begin

w:=a[j];

a[j]:=a[i];

a[i]:=w;

j:=j-1; {交换之后j的值应该减少，定位到前一个}

end

until i=j;

i:=i+1;

j:=j-1;

      if s<j then quicksort(a,s,j);

      if i<e then quicksort(a,i,e);

  end;

完整的参考程序如下:

program kuaisu(input,output);

const

n=20;

  type

    arr=array[1..n] of integer;

var

    s:arr;

    m:integer;

procedure quicksort(var a:arr; s,e:integer);

var

i,j:integer;

x,w:integer;

    begin

i:=s;

j:=e;

x:=a[i];

repeat

        while (a[j]<x) and (j>i) do {从后往前搜索比x大的数}

j:=j-1;

        if j>i then  {找到比x大的数后和前面的数进行交换}

begin

w:=a[i];

a[i]:=a[j];

a[j]:=w;

i:=i+1; {交换之后i的值应该增加，定位到后一个}

end;

        while (a[i]>x) and (i<j) do {从前往后搜索比x小的数}

i:=i+1;

        if i<j then

begin

w:=a[j];

a[j]:=a[i];

a[i]:=w;

j:=j-1; {交换之后j的值应该减少，定位到前一个}

end

until i=j;

i:=i+1;

j:=j-1;

      if s<j then quicksort(a,s,j);

if i<e then quicksort(a,i,e);

end; {过程结束}

Begin

Writeln('input 20 integer num:');

For m:=1 to n do

read(s[m]);

m:=1;

quicksort(s,m,n);

For m:=1 to n do

write(s[m]:4)

End.

练习:明明的随机数　全国青少年信息学奥林匹克分区联赛 (NOIp2006) 普及组第一题

[描述 Description]

   明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

[输入格式 Input Format]

   输入有2行，第1行为1个正整数，表示所生成的随机数的个数:N

第2行有N个用空格隔开的正整数，为所产生的随机数。

[输出格式 Output Format]

   输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。

[样例输入 Sample Input]

10

20 40 32 67 40 20 89 300 400 15

[样例输出 Sample Output]

8

15 20 32 40 67 89 300 400

[时间限制 Time Limitation]

全部点1s

参考程序:

program mm;

  var

    a,b:array[1..100] of integer;

    i,n,j,k:integer;

  begin

    read(n);

    for i:=1 to n do   {读入所有数据放在数组a中}

      read(a[i]);

    for i:=1 to n-1 do  {所有数据用冒泡法排序}

      for j:=1 to n-i do

         if a[j]>a[j+1]

           then begin

                  t:=a[j];

                  a[j]:=a[j+1];

                  a[j+1]:=t;

                end;

    k:=1;

    b[1]:=a[1];      {数组a中的第一个元素赋值给数组b的第一个元素}

    for i:=2 to n do

      if a[i]<>a[i-1]  {当本元素与前一个不相等时才赋给数组b}

        then begin

              k:=k+1;

              b[k]:=a[i];

             end;

    writeln(k);      {输出不同元素的个数}

    for i:=1 to k do

      write(b[i],' ');

  end.