排序算法学习程序

这个程序是我刚刚学OI的时候写的程序。因为那时候刚刚开学,又面临着开学考试,用了好几个晚上赶了出来,写的有些粗糙,请见谅。

那时候总是写程序写到晚上12点,这个程序也获得了2014年日照市中小学电脑制作活动二等奖……虽然不理想,但也是个奖……

既然活动结束了,我将公开源代码,请在FreePascal2.0.4下编译,然后再Windows下执行(不要直接Run,否则中文将显示乱码)

程序很简单,就是简单的输入输出操作,以及把各个简单排序算法整合在一起。

下面是源代码(转载或上传到网络时请注明作者版权,谢谢合作):

点击这里下载

program sort;
uses crt;
label 1,2;
type
arr=array[0..100] of integer;
var choose1,choose2,n,i,counter,cou:integer;
    a:array[0..100]of integer;
procedure selectionsort(a:array of integer);
 var i,j,k,t,r,counter:integer;
 begin
  counter:=0;
  for i:=1 to n-1 do
   begin
    k:=i;
    for j:=i+1 to n do
     if a[j]<a[k] then k:=j;
    if k<>i then
     begin
      inc(counter);
      t:=a[i];
      a[i]:=a[k];
      a[k]:=t;
      write(‘第‘,counter,‘次交换‘);
     for r:=1 to n do
       write(a[r],‘ ‘);
      readln;
     end;
   end;
 writeln(‘排序完毕!‘);
 readln;
 end;

procedure bubblesort(a:array of integer);
 var i,j,k,t,r,counter:integer;
 begin
 counter:=0;
 for i:=1 to n-1 do
   for j:=n downto i+1 do
    if a[j-1]>a[j] then
     begin
      inc(counter);
      t:=a[j-1];
      a[j-1]:=a[j];
      a[j]:=t;
      write(‘第‘,counter,‘次交换:‘);
      for r:=1 to n do
      write(a[r],‘ ‘);
      readln;
     end;
 writeln(‘排序完毕!‘);
 readln;
 end;

procedure insertionsort(a:array of integer);
 var i,j,k,t,r,counter:integer;
 begin
 counter:=0;
 for i:=2 to n do
  begin
   k:=a[i];
   j:=i-1;
   while (k<a[j]) and (j>0) do
    begin
       a[j+1]:=a[j];
       j:=j-1
    end;
   a[j+1]:=k;
   inc(counter);
   write(‘第‘,counter,‘轮:‘);
   for r:=1 to n do
     write(a[r],‘ ‘);
   readln;
  end;
  writeln(‘排序完毕!‘);
  readln;
 end;

procedure qsort(var d:arr;head,tail:longint);
var
   x,i,j,r:longint;
begin
   x:=d[head];  i:=head;  j:=tail;
   while i<j do
   begin
      while(i<j)and(d[j]>=x)do j:=j-1;
      d[i]:=d[j];
      while(i<j)and(d[i]<=x)do i:=i+1;
      d[j]:=d[i];
   end;
   d[i]:=x;
   inc(cou);
   write(‘第‘,cou,‘轮:‘);
   for r:=1 to n do write(a[r],‘ ‘);
   writeln;
   writeln(‘a[‘,i,‘]=‘,x,‘将区间[‘,head,‘,‘,tail,‘]分割成两个部分‘,‘,该数前面的数比它小,后面的数比它大.‘);
   readln;
   if head<j-1 then qsort(d,head,j-1);
   if i+1<tail then qsort(d,i+1,tail);
end;

begin
  randomize;
1:
  textcolor(white);
  writeln(‘   简单排序算法学习软件‘);
  textcolor(Green);
  writeln(‘请选择排序算法学习:‘);
  writeln(‘=========================‘);
  writeln(‘1.选择排序(SelectionSort)‘);
  writeln(‘2.冒泡排序(BubbleSort)‘);
  writeln(‘3.插入排序(InsertionSort)‘);
  writeln(‘4.快速排序(QuickSort)‘);
  writeln(‘=========================‘);
  writeln(‘5.关于作者‘);
  writeln(‘0.退出‘);
  writeln(‘==========‘);
     write(‘请选择:‘);
  repeat
     readln(choose1);
     writeln;
     if choose1=0 then halt;
     if choose1=5 then begin
          clrscr;
          writeln(‘作者:崔晨‘);
          writeln;
          writeln(‘莒县第一中学2013级7班‘);
          writeln;
          writeln(‘本程序为参赛作品,由崔晨独立编写;‘);
          writeln;
          writeln(‘其中参考了一些书籍或网络上关于排序算法的代码和相关描述;‘);
          writeln;
          writeln(‘程序主体部分为作者原创,排序算法的演示更是创新;‘);
          writeln;
          writeln(‘本程序采用FreePascal2.0.4编写,程序代码部分共410行;‘);
          writeln;
          writeln(‘如有建议欢迎批评指正.‘);
          readln;
          clrscr;
          goto 1;
       end;
     if (choose1<>1)and(choose1<>2)and(choose1<>3)and(choose1<>4)and(choose1<>5) then write(‘输入有误,请重新输入:‘);
  until (choose1=1)or(choose1=2)or(choose1=3)or(choose1=4)or(choose1=5);
  clrscr;
2:
    textcolor(white);
    case choose1 of
      1:write(‘  选择排序‘);
      2:write(‘  冒泡排序‘);
      3:write(‘  插入排序‘);
      4:write(‘  快速排序‘);
    end;
    writeln(‘学习‘);
    textcolor(green);
    writeln(‘1.程序模拟演示‘);
    writeln(‘2.算法描述‘);
    writeln(‘3.查看示例代码‘);
    writeln(‘0.返回主菜单‘);
    writeln(‘请选择:‘);
    repeat
    readln(choose2);
    if (choose2<>1)and(choose2<>2)and(choose2<>3)and(choose2<>0) then write(‘输入有误,请重新输入:‘);
  until (choose2=1)or(choose2=2)or(choose2=3)or(choose2=0);
  if choose1=1 then
   begin
     clrscr;
     if choose2=2 then
      begin
       writeln(‘(1)设数组a存放数据;‘);
       writeln;
       writeln(‘(2)在1~n中选择值最小的元素,与第1位置元素交换;‘);
       writeln;
       writeln(‘(3)在2~n中选择值最小的元素,与第2位置元素交换......‘);
       writeln;
       writeln(‘(4)直到第n-1元素与第n个元素比较排序为止‘);
       writeln;
       writeln;
       writeln(‘程序实现方法:用两重循环完成算法,外重循环i控制当前序列最小值存放的数组位置,‘);
       writeln(‘             内循环j控制i+1到n序列中选择最小的元素所在位置k.‘);
       writeln;
       writeln(‘算法时间复杂度为O(n^2)‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=3 then
      begin
       writeln(‘var a:array[0..1000] of longint;‘);
       writeln(‘    i,j,k,t:integer;‘);
       writeln(‘begin‘);
       writeln(‘ readln(n);‘);
       writeln(‘ for i:= 1 to n do read(a[i]);‘);
       writeln(‘ for i:=1 to n-1 do‘);
       writeln(‘  begin‘);
       writeln(‘   k:=i;‘);
       writeln(‘   for j:=i+1 to n do‘);
       writeln(‘    if a[j]<a[k] then k:=j;‘);
       writeln(‘   if k<>i then‘);
       writeln(‘    begin t:=a[i];a[i]:=a[k];a[k]:=t;end;‘);
       writeln(‘  end;‘);
       writeln(‘ for i:= 1 to n do write(a[i]:6);‘);
       writeln(‘ end.‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=1 then
      begin
       writeln(‘请输入演示数据的个数(系统将随机产生数据),建议不超过15:‘);
       readln(n);
       for i:=1 to n do
         a[i]:=random(1000);
       write(‘未排序前:‘);
       for i:=1 to n do
         write(a[i],‘ ‘);
       writeln;
       selectionsort(a);
       clrscr;
       goto 2;
      end;
    end;
  if choose1=2 then
    begin
     clrscr;
     if choose2=2 then
      begin
       writeln(‘(1)设数组a存放数据;‘);
       writeln;
       writeln(‘(2)对尚未排序的各元素从头到尾依次比较相邻的两个元素是否逆序(与预排顺序相反),‘);
       writeln(‘   若逆序就交换这两个元素;‘);
       writeln;
       writeln(‘(3)经过第一轮比较后便可把最大(或最小)的元素排好;‘);
       writeln;
       writeln(‘(4)用同样的办法把剩下的元素逐个比较,如果有n个元素,‘);
       writeln(‘   那么一定要进行n-1轮比较,就得到了所需要的排序.‘);
       writeln;
       writeln(‘程序实现方法:用两重循环完成算法,外重循环i控制每轮要进行多少次的比较,‘);
       writeln(‘             第一轮比较n-1次,第二轮n-2次......最后一轮比较一次.‘);
       writeln(‘             内重循环j控制每轮i次比较相邻两个元素是否逆序,若逆序就交换这两个元素‘);
       writeln;
       writeln(‘算法时间复杂度为O(n^2)‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=3 then
      begin
       writeln(‘var a:array[0..1000] of integer;‘);
       writeln(‘    i,j,k,t:integer;‘);
       writeln(‘begin‘);
       writeln(‘readln(n);‘);
       writeln(‘ for i:= 1 to n do read(a[i]);‘);
       writeln(‘ for i:=1 to n-1 do‘);
       writeln(‘      for j:=1 to n-i do‘);
       writeln(‘       if a[j]>a[j+1] then‘);
       writeln(‘        begin t:=a[j+1];a[j+1]:=a[j];a[j]:=t; end;‘);
       writeln(‘ for i:= 1 to n do write(a[i]:6);‘);
       writeln(‘ end.‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=1 then
      begin
       writeln(‘请输入演示数据的个数(系统将随机产生数据),建议不超过15:‘);
       readln(n);
       for i:=1 to n do
         a[i]:=random(1000);
       write(‘未排序前:‘);
       for i:=1 to n do
         write(a[i],‘ ‘);
       writeln;
       bubblesort(a);
       clrscr;
       goto 2;
      end;
    end;
 if choose1=3 then
   begin
     clrscr;
     if choose2=2 then
      begin
       writeln(‘(1)设数组a存放数据;‘);
       writeln;
       writeln(‘(2)从第2个数开始,取出当前数作为待排序数,逐个与前面的数比较,‘);
       writeln(‘   若小于前面的数,则前面数后移,当大于等于前面数时,插入当前空出的位置.‘);
       writeln;
       writeln(‘(3)直到第n个数插入到正确位置为止.‘);
       writeln;
       writeln;
       writeln(‘程序实现方法:用两重循环完成算法,外重循环i控制待排数字序数,‘);
       writeln(‘             从第2个数到第n个数,内重循环j控制插入的位置,‘);
       writeln(‘             j值从i-1开始向前扫描,边扫描边将数据后移,寻找到位置,插入当前值.‘);
       writeln;
       writeln(‘算法时间复杂度为O(n^2)‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=3 then
      begin
       writeln(‘var a:array[0..1000] of longint;‘);
       writeln(‘    n,i,j:longint;‘);
       writeln(‘begin‘);
       writeln(‘ readln(n);‘);
       writeln(‘ for i:= 1 to n do read(a[i]);‘);
       writeln(‘ for i:=2 to n do‘);
       writeln(‘  begin‘);
       writeln(‘   a[0]:=a[i];j:=i-1;‘);
       writeln(‘   while (a[0]<a[j]) and (j>0) do‘);
       writeln(‘    begin a[j+1]:=a[j];j:=j-1 end;‘);
       writeln(‘   a[j+1]:=a[0];‘);
       writeln(‘  end;‘);
       writeln(‘ for i:= 1 to n do write(a[i]:6);‘);
       writeln(‘ end.‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=1 then
      begin
       writeln(‘请输入演示数据的个数(系统将随机产生数据),建议不超过15:‘);
       readln(n);
       for i:=1 to n do
         a[i]:=random(1000);
       write(‘未排序前:‘);
       for i:=1 to n do
         write(a[i],‘ ‘);
       writeln;
       insertionsort(a);
       clrscr;
       goto 2;
      end;
   end;
 if choose1=4 then
   begin
     clrscr;
     if choose2=2 then
      begin
       writeln(‘(1)首先从待排序区间(初始时为[1..n])中选取一个元素作为基准元素;‘);
       writeln(‘   (方便起见,一般是选取区间内的第一个元素)‘);
       writeln;
       writeln(‘(2)然后从两端向中间依次进行比较和交换,‘);
       writeln(‘   把位于基准元素之前且比基准元素大的交换到后面;‘);
       writeln(‘   把位于基准元素之后且比基准元素小的交换到前面‘);
       writeln;
       writeln(‘(3)直至基准元素位于前后两部分的交界处‘);
       writeln(‘   这样前面部分的所有元素都小于等于基准元素‘);
       writeln(‘   后面部分的所有元素均大于等于基准元素‘);
       writeln(‘   基准元素的所在位置就是排序后的最终位置‘);
       writeln;
       writeln(‘(4)然后再对基准元素的前后两个区间分别进行快速排序‘);
       writeln(‘   直至每个区间为空或只包含一个元素,整个快速排序结束‘);
       writeln;
       writeln(‘最理想时间复杂度:O(nlogn);‘);
       writeln(‘最差时间复杂度:O(n^2)‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=3 then
      begin
       writeln(‘var n,i:longint;‘);
       writeln(‘    d:array[1..10000]of longint;‘);
       writeln(‘procedure qsort(head,tail:longint);‘);
       writeln(‘var x,i,j:longint;‘);
       writeln(‘begin‘);
       writeln(‘   x:=d[head];  i:=head;  j:=tail;‘);
       writeln(‘   while i<j do‘);
       writeln(‘   begin‘);
       writeln(‘      while(i<j)and(d[j]>=x)do j:=j-1;‘);
       writeln(‘      d[i]:=d[j];‘);
       writeln(‘      while(i<j)and(d[i]<=x)do i:=i+1;‘);
       writeln(‘      d[j]:=d[i];‘);
       writeln(‘   end;‘);
       writeln(‘   d[i]:=x;‘);
       writeln(‘   if head<j-1 then qsort(head,j-1);‘);
       writeln(‘   if i+1<tail then qsort(i+1,tail);‘);
       writeln(‘end;‘);
       writeln(‘begin‘);
       writeln(‘    readln(n);‘);
       writeln(‘    for i:=1 to n do read(d[i]);‘);
       writeln(‘    qsort(1,n);‘);
       writeln(‘    for i:=1 to n do writeln(d[i]);‘);
       writeln(‘end.‘);
       readln;
       clrscr;
       goto 2;
      end;
     if choose2=1 then
      begin
       cou:=0;
       write(‘请输入演示数据的个数(系统将随机产生数据),建议不超过15:‘);
       writeln;
       readln(n);
       for i:=1 to n do
         a[i]:=random(1000);
       write(‘未排序前:‘);
       for i:=1 to n do
         write(a[i],‘ ‘);
       writeln;
       qsort(a,1,n);
       writeln(‘排序完毕!‘);
       readln;
       clrscr;
       goto 2;
      end;
   end;
  if choose2=0 then goto 1;
end.

仅供学习和研究,请大神勿喷。

排序算法学习程序

时间: 2024-10-08 14:51:48

排序算法学习程序的相关文章

经典排序算法 - 冒泡排序Bubble sort

 原文出自于 http://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html 经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第

排序算法比较及其应用

一.将各种数据排序 只要实现了Comparable接口的数据类型就可以被排序. 但要使算法能够灵活地用不同字段进行排序,则是后续需要考虑的问题. 1.指针排序 在Java中,指针操作是隐式的,排序算法操作的总是数据引用,而不是数据本身. 2.键不可变 如果在排序后,用例还可以改变键值,那么数组很可能就不是有序的了.类似,优先队列也会乱套. Java中,可以用不可变数据类型作为键来避免这个问题,如String,Integer,Double和File都是不可变的. 3.廉价交换 使用引用的另一个好处

选择排序 —— 排序算法系列

假设我们有如下一个数组: 使用选择排序算法对这个数组进行排序,步骤如下: 第 1 次 在下标0到6之间找到最小的数字,我们可以发现最小的数字是15,它在下标为4的位置上: 把下标4上面的数字跟下标0上面的数字互换,得到排序如下图的数组: 第 2 次 在下标1到6之间找到最小的数字,我们可以发现最小的数字是33,它在下标为5的位置上: 把下标5上面的数字跟下标1上面的数字互换,得到排序如下图的数组: 第 3 次 在下标2到6之间找到最小的数字,我们可以发现最小的数字是48,它在下标为5的位置上:

排序算法Java版,以及各自的复杂度,以及由堆排序产生的top K问题

常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结束.时间复杂度:O(n^2) 选择排序:每次在无序队列中"选择"出最大值,放到有序队列的最后,并从无序队列中去除该值(具体实现略有区别).时间复杂度:O(n^2) 直接插入排序:始终定义第一个元素为有序的,将元素逐个插入到有序排列之中,其特点是要不断的 移动数据,空出一个适当的位置,把待插

排序算法总结

各种排序算法总结  排序算法  插入排序 冒泡排序  选择排序  归并排序  快速排序 堆排序  计数排序  基数排序  桶排序  思想  构建有序序列 两两交换 每次找一个最小值 分治法思想 分治法思想 最小堆.最大堆 数字本身的属性  对数据选择多种基数  函数的映射关系.Hash  数据结构  数组  数组  数组  数组 不定   数组 数组 数组  数组  最差时间复杂度 O(n^2)   O(n^2)   O(n^2)   O(n*lgn)  O(n^2).改进O(n*lgn)  O

七大常见排序算法总结

文档版本 开发工具 测试平台 工程名字 日期 作者 备注 V1.0 2016.04.06 lutianfei none V1.1 2016.07.16 lutianfei 增加了归并排序说明 V2.0 2016.07.19 lutianfei 完善了排序算法的总结 排序另一种分法 外排序:需要在内外存之间多次交换数据才能进行 内排序: 插入类排序 直接插入排序 希尔排序 选择类排序 简单选择排序 堆排序 交换类排序 冒泡排序 快速排序 归并类排序 归并排序 排序方法 平均情况 最好情况 最坏情况

数据结构——各排序算法的比较

1.从时间复杂度比较  从平均时间复杂度来考虑,直接插入排序.冒泡排序.直接选择排序是三种简单的排序方法,时间复杂度都为O(n2),而快速排序.堆排序.二路归并排序的时间复杂度都为O(nlog2n),希尔排序的复杂度介于这两者之间.若从最好的时间复杂度考虑,则直接插入排序和冒泡排序的时间复杂度最好,为O(n),其它的最好情形同平均情形相同.若从最坏的时间复杂度考虑,则快速排序的为O(n2),直接插入排序.冒泡排序.希尔排序同平均情形相同,但系数大约增加一倍,所以运行速度将降低一半,最坏情形对直接

八种排序算法

最近一段时间自己在研究各种排序算法,于是自己写了一个八种排序算法的集合: /************************************************************************* > Copyright (c)2014 stay hungry,stay foolish !!! > File Name: sort.cpp > Author: kanty > Mail: [email protected] > Created Time:

排序算法 之 快速排序

快速排序是基于分治思想的一种排序算法,就像该方法的名字一样,速度比较快,所以叫做快速排序:它的平均时间复杂度为O(N*logN),最坏时间复杂度为O(n2),由于快速排序在序列元素数量多的时候速度比较快,所以很多语言内置的排序方法也是用快速排序实现的.快速排序也有很多优化的版本,比如在排序时基数的选择等等-下面就说一下一般的快速排序的实现. 基本思想: 快速排序的基本思想就是,先从待排序的序列中任选一个元素作为基数,然后将序列中的其他小于基数的元素放在基数的左边,大于或等于基数的元素放在基数的右