排序算法小结

排序算法

概述

排序算法的目的实现一组无序元素的有序化。排序通常分为主存排序和外部排序，主存排序是数据量不是太大，整个排序过程在内存中完成，外部排序由于数据量太大在主存中没法完成排序，需要在磁盘或磁带上完成的排序。

主存排序包括：插入排序（O(N2)）、希尔排序(O(N2))、归并排序(O(NlogN))、堆排序(O(NlogN))、快速排序(O(NlogN))、桶式排序(O(N))。

算法分析

在算法分析中，将会对各种排序算法的特点，实现原理进行介绍说明，源码大家可以去网上搜索或留言。

插入排序

插入排序由N-1趟排序组成，对于p=1到N-1趟，插入排序保证从位置0到位置p上的元素为已排序状态。当进行第k次排序时，从0到k-1个元素都是已排序状态，第k个元素依次与k-1到0个元素进行比较，直到第k个元素大于被比较元素，停止。

希尔排序

希尔排序通过比较相隔一定元素来工作，比较的间隔距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。希尔排序使用一个序列h1,h2……ht作为增量序列，作为每次比较间隔的元素个数，该增量序列的选择非常重要，决定着整个算法的计算时间。增量序列的一个流程的选择是使用Shell建议的序列：ht=N/2和hk=h(k+1)/2。伪代码为：

For从gap=length/2到1，变换因子除2

  For i从gap到a.length，++

     For j从i到gap，j-=gap

       Tmp=a[i];

       若a[j]大于a[i],则a[i]=a[j]；

     a[j]=tmp;

堆排序

堆排序主要是利用了优先队列数据结构，完成步骤包括构造二叉堆（花费O(N)），然后在进行N次删除根节点（花费O(NlogN)），把删除的根节点存储到一个新的数组中（花费O(N)）。有一个问题在于它使用了一个附加的数组。关键代码为上虑代码，其伪代码如下:

perDown(a[],int i,int length)

int temp=a[i];

a[i]=a[length];

int child;

for(int j=i;2*child+1<length;i=child){

child=2*i;

if(a[2*i]>a[2*i+1])

child++;

if(a[i]>a[child])

{

a[i]=a[child]

}else{

Break;

}

a[i]=temp;

}

归并排序

归并排序的核心为递归思想，并对两个已经排好序的表进行排序，花费时间为O(NlogN)。如表1和表2为已经排好序的表，两个表的排序结果存储在表3中，代码实现为：

public void mergeSort(int left,int right,int[] input,int[] tmp){

       if(left>=right)

           return;

       int middle=(left+right)/2;

       mergeSort(left,middle,input,tmp);

       mergeSort(middle+1,right,input,tmp);

      

      

    }

   

    private void merge(int left,int middle,int end,int[] a,int[] tmp){

       int right=middle+1;

       int tmpPos=left;

       while(left<=middle && right<=end){

           if(tmp[left]>tmp[right]){

              tmp[tmpPos++]=tmp[right++];

           }else{

              tmp[tmpPos++]=tmp[left++]; 

           }

       }

       while(left<=middle){

           tmp[tmpPos++]=a[left];

           left++;

       }

       while(right<=end){

           tmp[tmpPos++]=a[right];

           right++;

       }

      

       for(int i=0;i<a.length;i++){

           a[i]=tmp[i];

       }

    }

快速排序

快速排序平均运行时间是O(NlogN)，该算法也是一种分治的递归算法。其排序过程主要包括三个过程：

1、  选取枢纽元，作为比较的关键元素；

2、  根据枢纽元的位置把表分为两个部分A和B，比该元素小的放到左边，比该元素大的放到右边；

3、  对A和B两个部分在进行快速排序。

具体代码实现为：

public void quickSort(int start,int end, int[] input) {

       media(start, end, input);

       int left = start;

       int right = end - 1;

       while (left < right) {

           while (input[left] < input[end]) {

              left++;

           }

           while (input[right] > input[end]) {

              right--;

           }

           int tmp = input[left];

           input[left] = input[right];

           input[right] = tmp;

       }

 

 

       int tmp= input[left + 1];

       input[left + 1] = input[end];

       input[end] = tmp;

 

       quickSort(start, left, input);

       quickSort(left + 1, end, input);

 

    }

 

    private void media(int start,int end, int[] input) {

       int middle = (start + end) / 2;

       if (input[start] > input[middle]) {

           int tmp = input[start];

           input[start] = input[middle];

           input[middle] = tmp;

       }

       if (input[middle] > input[end]) {

           int tmp = input[middle];

           input[end] = input[middle];

           input[middle] = tmp;

           if (input[start] > input[middle]) {

              tmp = input[start];

              input[start] = input[middle];

              input[middle] = tmp;

           }

       }

       int tmp = input[middle];

       input[end] = input[middle];

       input[middle] = tmp;

    }

桶式排序

桶式排序是计算总量花费O(N)，相当于是一个时空的转换过程，对排序的数据有一定的限制作用，必须为整数类型元素，输入数据A1、A2、……必须只由小于M的正整数组成，算法很简单：使用一个大小为M的count数据，它被初始化为全0，于是，具有M个单元或称为桶。当读Ai时，count[Ai]=1。在所有输入数据读入后，扫描数据count，打印出排序后的表。