Fortran快速排序

处理数据的时候经常要用排序法，但是无可奈何我好像找不到gfortran上现成的排序程序。于是自己在写数学函数库的时候，也加入了这一部分的内容。

起先写的是冒泡排序，但是同学建议我冒泡排序太慢了，对于数量多起来的排序时间会变得非常夸张，于是乎3.29下午开始学习快速排序。3.30中午终于把gfortran的快速排序代码写好了。。。。。 算法详解什么的有空再写吧，先贴代码。。。。

recursive subroutine Fast_Sort(A,sort_type)
        real :: A(:)
        character(len=*),optional :: sort_type
        integer :: head,tail,i,s
        real :: temp
        real :: pivot
        if (.not. present(sort_type)) then
                sort_type='asc'
        end if
        head=0
        tail=size(A)+1
        pivot=A(1)
loop1:  do while (.true.)
                tail=tail-1
                head=head+1
tail_loop:      do while (.true.)
                        if (A(tail) <= pivot) then
                                exit tail_loop
                        end if
                        tail=tail-1
                end do tail_loop

head_loop:      do while (.true.) 
                        if (A(head) > pivot) then
                                exit head_loop
                        end if
                        head=head+1
                        if (head > size(A)) then
                                exit head_loop
                        end if
                end do head_loop

                if (head < tail) then
                        temp=A(head)
                        A(head)=A(tail)
                        A(tail)=temp
                else if (head == tail) then
                        temp=A(head)
                        A(head)=A(1)
                        A(1)=temp
                        exit loop1
                else if (head > tail) then
                        temp=A(tail)
                        A(tail)=A(1)
                        A(1)=temp
                        exit loop1
                end if
        end do loop1
                if (size(A(:tail-1)) > 1) then
                        call Fast_Sort(A(:tail-1))
                end if

                if (size(A(tail+1:)) > 1) then
                        call Fast_Sort(A(tail+1:))
                else 
                        return
                end if

        if (trim(adjustl(sort_type)) == 'desc') then
                call reverse_array(A)
        end if


contains

subroutine reverse_array(array)
        implicit none
        real :: array(:)
        integer :: s,i,temp

        s=size(array)

        do i=1,s/2
                temp=array(i)
                array(i)=array(s+1-i)
                array(s+1-i)=temp
        end do
end subroutine reverse_array

end subroutine Fast_Sort

使用了Fortran递归的方法写的快速排序算法。其实本体只有升序排序，如果可选输入参数为‘desc’，这个时候就会启动后面的reverse_array程序，将升序排号的结果翻转就是降序啦（偷懒第一名。。。。，其实是不会写降序，不要问我为什么？？？）。子程序我是放在模块里面使用的，所以实际上需要给这个子程序增加一个显式接口，关于显式接口可以上网搜。简单暴力操作就是在这个程序上下方加上如下内容：

module xxxx(自己定模块的名字)
contains

#这里放上面的代码

end module xxxx(和前面的名字一致)

如果想要将子程序和主程序放在一起，可以将上述内容放在主程序之前(模块必须放在主程序之前)然后在主程序中，在implicit none之前写上：

use xxx(这个名字是module的名字)
implicit none

然后在需要使用的时候就可以：

call Fast_Sort(A,'asc/desc')

A为需要排序的数组，后一个参数可以输入字符串’asc’和’desc’，输入’asc’的时候为升序排列，’desc’时为降序排列，**当不输入第二个参数或者输入的第二个参数不是‘asc’和’desc’其中之一时，默认为升序。**

最后是对于10w个随机数，使用冒泡排序和快速排序二者所耗时间比较，时间是cpu时间，单位应该是s吧？

效果还是很明显的，快速排序耗时远远小于冒泡排序，嘻嘻~~

至于如果想把子程序和主程序分开放，可以上网搜一下Fortran的静态库或者动态库的编译和链接，这里就不详细讲了，认识我的话可以来问我hhhhh~

就这样啦，拜拜~~