八大排序算法

参考http://blog.csdn.net/hguisu/article/details/7776068#t7

概述

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

我们这里说说八大排序就是内部排序。

    

    当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

算法中引进的附加记录R[0]称监视哨或哨兵(Sentinel)。（看大话数据结构代码）

哨兵有两个作用：

① 进人查找(插入位置)循环之前，它保存了R[i]的副本，使不致于因记录后移而丢失R[i]的内容；

② 它的主要作用是：在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0)，因为R[0].可以和自己比较，循环判定条件不成立使得查找循环结束，从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")。

直接插入排序示例：

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法的实现：

public class InsertSort{
     
    public void insertSort(int[] array){
        for(int i=1;i<array.length;i++)//第0位独自作为有序数列，从第1位开始向后遍历
        {
            if(array[i]<array[i-1])//0~i-1位为有序，若第i位小于i-1位，继续寻位并插入，否则认为0~i位也是有序的，忽略此次循环，相当于continue
            {
                int temp=array[i];//保存第i位的值
                for(int j=i-1;j>=0 && temp<array[j];j--)//从第i-1位向前遍历并移位，直至找到小于第i位值停止
                {
                    array[j+1]=array[j];
                }
                array[j+1]=temp;//插入第i位的值
            }
        } 
    }
     
    public static void printArray(int[] array) {
          for (int i = 0; i < array.length; i++) {
               System.out.print(array[i]);
               if (i != array.length - 1) {
                System.out.print(",");
               }
          }
     }
}

效率：

时间复杂度：平均O（n^2），最差O（n^2），最优O（n）。

空间复杂度：附加空间O（1）。

性能：稳定。

 2. 插入排序—希尔排序（Shell Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序。

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序的示例：

算法实现：

 

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

public static void main(String [] args)
{
    int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前：");
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ");
        }
        //希尔排序
        int d=a.length;
            while(true)
            {
                d=d/2;
                for(int x=0;x<d;x++)
                {
                /*
                开始直接插入排序，增量由1变为d
                */
                    for(int i=x+d;i<a.length;i=i+d)
                    {
                        int temp=a[i];
                        for(int j=i-d;j>=0&&a[j]>temp;j=j-d)
                        {
                            a[j+d]=a[j];
                        }
                        a[j+d]=temp;
                    }
                }
                if(d==1)//判断终止条件
                {
                    break;
                }
            }
            System.out.println();
            System.out.println("排序之后：");
                for(int i=0;i<a.length;i++)
                {
                    System.out.print(a[i]+" ");
                }
    }

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的 增量因子序列 的方法。 增量因子序列 可以有各种取法，有取奇数的，也有取质数的，但需要注意： 增量因子 中除1 外没有公因子，且 最后一个增量因子必须为1 。希尔排序方法是一个不稳定的排序方法。

效率：

时间复杂度：平均O（n^1.3），最差O（n^2），最优O（n）。

空间复杂度：附加空间O（1）。

性能：不稳定（跳跃式的移动）。

3. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

操作方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

算法实现：

package notes.javase.algorithm.sort;  
  import java.util.Random;
    public class SelectionSort { 
      public void selectionSort(int[] list) {
          // 需要遍历获得最小值的次数
          // 要注意一点，当要排序 N 个数，已经经过 N-1 次遍历后，已经是有序数列
         for (int i = 0; i < list.length - 1; i++) {
             int temp = 0;
             int index = i; // 用来保存最小值得索引  
             // 寻找第i个小的数值
             for (int j = i + 1; j < list.length; j++) {
                 if (list[index] > list[j]) {
                     index = j;
                 }
             }  
             // 将找到的第i个小的数值放在第i个位置上
             temp = list[index];
             list[index] = list[i];
             list[i] = temp;  
             System.out.format("第 %d 趟:\t", i + 1);
             printAll(list);
         }
     } 
     // 打印完整序列
     public void printAll(int[] list) {
         for (int value : list) {
             System.out.print(value + "\t");
         }
         System.out.println();
     }  
     public static void main(String[] args) {
         // 初始化一个随机序列
         final int MAX_SIZE = 10;
         int[] array = new int[MAX_SIZE];
         Random random = new Random();
         for (int i = 0; i < MAX_SIZE; i++) {
             array[i] = random.nextInt(MAX_SIZE);
         } 
         // 调用冒泡排序方法
         SelectionSort selection = new SelectionSort();
         System.out.print("排序前:\t");
         selection.printAll(array);
         selection.selectionSort(array);
         System.out.print("排序后:\t");
         selection.printAll(array);
     }

}

效率：

时间复杂度：

          简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元素，则比较次数总是N (N - 1) / 2  （1+...+(N-1)）。

而移动次数与序列的初始排序有关。当序列正序时，移动次数最少，为 0。

在最坏情况下为3(n-1)次（外循环执行n-1次，每次移动有三条赋值语句，固为3(N-1)次）。

         所以，综合以上，简单排序的时间复杂度为 O(N^2)。

空间复杂度：附加空间O（1），交换数值时使用。

性能：不稳定。

4. 选择排序—堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足（ki为双亲借点，k2i、k2i+1分别为左右孩子）

时称之为堆。

堆是具有如下性质的的完全二叉树：每个结点的值都≤（或≥）其左右孩子的结点的值。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：

1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

public static void heapSort(int[] array) {  
    /* 
     *  第一步：将数组堆化 
     *  beginIndex = 第一个非叶子节点。 
     *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。 
     *  叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。 
     */  
    int len = array.length - 1;  
    int beginIndex = (len - 1) >> 1;  
    for (int i = beginIndex; i >= 0; i--) {  
        maxHeapify(i, len, array);  
    }  
    /* 
     * 第二步：对堆化数据排序 
     * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。 
     * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。 
     * 直至未排序的堆长度为 0。 
     */  
    for (int i = len; i > 0; i--) {  
        swap(0, i, array);  
        maxHeapify(0, i - 1, array);  
    }  
    System.out.println(Arrays.toString(array) + " heapSort");  
}  
private static void swap(int i, int j, int[] arr) {  
    int temp = arr[i];  
    arr[i] = arr[j];  
    arr[j] = temp;  
}  
/** 
 * 调整索引为 index 处的数据，使其符合堆的特性。 
 * 
 * @param index 需要堆化处理的数据的索引 
 * @param len   未排序的堆（数组）的长度 
 */  
private static void maxHeapify(int index, int len, int[] arr) {  
    int li = (index << 1) + 1; // 左子节点索引  
    int ri = li + 1;           // 右子节点索引  
    int cMax = li;             // 子节点值最大索引，默认左子节点。  
    if (li > len) {  
        return;       // 左子节点索引超出计算范围，直接返回。  
    }  
    if (ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。  
    { cMax = ri; }  
    if (arr[cMax] > arr[index]) {  
        swap(cMax, index, arr);      // 如果父节点被子节点调换，  
        maxHeapify(cMax, len, arr);  // 则需要继续判断换下后的父节点是否符合堆的特性。  
    }  
}  

效率：

时间复杂度（大话数据结构P405）：

          在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端节点开始建，将它与其孩子进行比较和若有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个构建堆的时间复杂度为O(N)；

         所以，综合以上，堆排序的最优、最差、平均时间复杂度均为O(N*logN)。

空间复杂度：附加空间O（1），交换元素时使用。

性能：不稳定。

5. 交换排序—冒泡排序（Bubble Sort）

基本思想：

冒泡排序算法的运作如下:

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
3. 针对所有的元素重复以上的步骤，除了最后一个。 
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序的示例：

 

算法的实现：

public class BubbleSort{
    public static int[] bubbleSort(int[] array){
        for(int i = 0;i < array.length;i++){                                            
            for(int j = 0; j < array.length-i-1;j++){
                if(array[j] > array[j+1]){                        
                    int temp = array[j];  
                    array[j] = array[j+1]; 
                    array[j+1] = temp;    
                }
            }
            System.out.println("第"+(i+1)+"趟排序");
            for(int k = 0;k < array.length;k++){
                System.out.print(array[k]+"  ");
            }
            System.out.println();
        }
        return array;
    }
    public static void main(String[] args){
        int[] array = {7,3,9,5,6,8,1};
        bubbleSort(array);
    }

}

冒泡排序算法的改进

对冒泡排序常见的改进方法是加入一标志性变量NeedNextPass，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

改进后算法如下:

public class bubbleImprovedSort {
    //冒泡排序
    public static void bubbleSort(int[] list){
            int n=list.length;
            boolean NeedNextPass=true;
            for(int i=1;i<n&&NeedNextPass;i++){//总共比较n-1趟，如果某趟遍历中没有交换，那么不需要下次遍历，因为元素以排好
                NeedNextPass=false;
                for(int j=0;j<n-i;j++){//第i趟比较n-i次
                    if(list[j]>list[j+1]){
                        int temp;
                        temp=list[j];
                        list[j]=list[j+1];
                        list[j+1]=temp;     
                        NeedNextPass=true;
                    }
                }
            }
        }
        public static void main(String args[]){
            int[] list={2,1,56,34,9,6,55,20,37,22};   
            System.out.println("排序前的list是：");
            for(int i=0;i<list.length;i++){
                System.out.print(list[i]+" ");
            }
            bubbleSort(list);//进行冒泡排序
            System.out.println();
            System.out.println("排序后的list是：");
            for(int i=0;i<list.length;i++){
                System.out.print(list[i]+" ");
            }
        }
}

效率：

时间复杂度：

          相邻两个数进行比较把大的数放在右边，循环后最大的数再数组的最右边，对剩余n-1个数使用同样的方法，最优时间复杂度O(n)，最差时间复杂度O(n^2)，平均时间复杂度为O(n^2)。

空间复杂度：附加空间O（1），交换元素时使用。

性能：稳定。

6. 交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

一趟快速排序的算法是：

1）设置两个变量i、j， 排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给 key，即 key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于 key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于 key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于 key,4中A[i]不大于 key的时候改变j、i的值，使得j=j-1，i=i+1，直至到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

 递归实现：

public class QuickSort {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = {9,2,7,6,4,8,1,3,5};
		print(a);
		quickSort(a,0,a.length-1);
		print(a);
	}
	private static void print(int[] a) {
		// TODO Auto-generated method stub
		for (int i : a) {
			System.out.print(i+",");
		}
		System.out.println();
	}	
	private static void quickSort(int[] a, int left,int right){
		//当可以进行快排时
		if(left < right){
			//把最左边的值设为key，把left的值赋给low，right的值赋给high
			int key = a[left];
			int low = left;
			int high = right;
			//当low<high时，循环把比key更大的放在它右边，比key更小的值放在它的左边
			while(low<high){
				//如果右边的值大于key则一直向后对比
				while(low < high && a[high] >= key){
					high--;
				}
				//符合是把高位的值赋给低位的值
				a[low] = a[high];
				//如果左边的值一直小于key则一直向前对比
				while(low < high && a[low] < key){
					low++;
				}
				//把地位的值赋值给高位
				a[high] = a[low];
			}
			//把key的值赋给指针停止的地方
			a[low] = key;
			quickSort(a,left,low-1);
			quickSort(a,low+1,right);				
		}
	}
}

效率：

时间复杂度：

          快速排序是对于冒泡排序的改进，把中间值作为一个key，左边放的是比key小的值，右边是比key大的值，然后key左边的数进行快排，右边也进行快排，递归结束，最优时间复杂度为O(NlogN)，最差时间复杂度为O(N^2)，平均时间复杂度为O(NlogN)。

空间复杂度：附加空间O（logN），递归树的深度为logN。

性能：不稳定。

快速排序的改进 具体见另一帖子。

7. 归并排序（Merge Sort）

基本思想：

归并排序是指通过对若干个有序结点序列的归并来实现排序，所谓归并是指将若干个已排好序的部分根据算法合并成一个新的有序整体。

比如两个有序的子序列array[low,...,mid]和array[mid+1,...,high]，设置i,j两个指针指向low和mid+1，合并时依次比较array[i]和array[j]的值，取较小值记录复制到暂存序列temp[]中，在用p指向该暂存序列，每复制一次，让较小值的下标i或者j自增一次，同时p也自增一次。重复这一过程直至两个子序列中有一个已全部复制完毕，此时将另一非空的子序列中的剩余数据依次复制到array中即可。

算法实现：

其中数组r保存排序后的结果，s为待排序源数据数组

package mergeSort;  
  
public class MergeSort {  
      
    public static int [] s = new int[]{5,11,6,4,1,10,9,8,7};  
    public static int [] r = new int[s.length];  
      
    public static void main(String[] args) {  
        printArr(s, "排序前:   ");  
        mergeSort(r,s,0,s.length - 1);//调用归并排序  
        printArr(r, "排序后:   ");//打印排序结果  
    }  
      
    //执行归并排序  
    public static void mergeSort(int [] r, int [] s, int begin, int end){  
        if(begin == end){  
            return;  
        }  
        int middle = (begin + end)/2;  
        mergeSort(r, s, begin, middle);  
        mergeSort(r,s, middle + 1, end);  
        merge(r, s, begin, middle, end);  
    }  
      
    //把两个无序的子序列s[begin]~s[middle]和子序列s[middle + 1]~s[end]合并为一个有序序列r[begin]~r[end],然后回写到s[begin]~s[end]  
    public static void merge(int [] r, int [] s, int begin, int middle, int end){  
        int i = begin;  
        int j = middle + 1;  
        int k = begin;  
        while(i <= middle && j <= end){  
            if(s[i] <= s[j]){  
                r[k++] = s[i++];  
            }else{  
                r[k++] = s[j++];  
            }  
        }  
          
        if(i <= middle){  
            for(; i <= middle; i++){  
                r[k++] = s[i];  
            }  
        }  
          
        if(j <= end){  
            for(; j <= end; j++){  
                r[k++] = s[j];  
            }  
        }  
          
        //把有序序列r[begin]~r[end],回写到s[begin]~s[end],这一步很重要  
        for(int l = begin; l <= end; l++){  
            s[l] = r[l];  
        }  
    }  
      
    public static void printArr(int [] arr, String flag){  
        System.out.print(flag);  
        for(int i = 0; i < arr.length; i++){  
            System.out.print(arr[i] + " ");  
        }  
        System.out.println();  
    }  
}  

效率：

时间复杂度：

         归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。归并排序的最好、最坏和平均的时间复杂度均为O(nlogn)，空间复杂度为O(n)。但却是一种效率高且稳定的算法。

空间复杂度：附加空间O（N）。归并排序比较占用内存（相对于快排的空间复杂度O(logn)以及堆排序的空间复杂度O(1)，其中三者时间复杂度相同），当n比较大的时候，归并排序往往会出内存溢出错误。

性能：稳定。

8. 桶排序（Bucket Sort）/基数排序(Radix Sort)

说基数排序之前，我们先说桶排序：

基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。

桶排序中：无序数组有个要求,就是成员隶属于固定(有限的)的区间,如范围为0-9

排序过程：

例如待排数字[6 2 4 1 5 9]

准备10个空桶,最大数个空桶

[6 2 4 1 5 9]           待排数组

[0 0 0 0 0 0 0 0 0 0]   空桶

[0 1 2 3 4 5 6 7 8 9]   桶编号(实际不存在)
 
 
1
2
3
4
5
 
 
1
2
3
4
5

1）顺序从待排数组中取出数字,首先6被取出,然后把6入6号桶,这个过程类似这样:空桶[ 待排数组[ 0 ] ] = 待排数组[ 0 ]

[6 2 4 1 5 9] 待排数组

[0 0 0 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

2）顺序从待排数组中取出下一个数字,此时2被取出,将其放入2号桶,是几就放几号桶

[6 2 4 1 5 9] 待排数组

[0 0 2 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

3,4,5,6省略,过程一样,全部入桶后变成下边这样

[6 2 4 1 5 9] 待排数组

[0 1 2 0 4 5 6 0 0 9] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

0表示空桶,跳过,顺序取出即可:1 2 4 5 6  9

         简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

 首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

  然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

  最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

  假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

  对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

  当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

        前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

        2）其次待排序的元素都要在一定的范围内等等。

       桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。

不太重要，附一个简单的排序代码

/** 
 * 题目： 
 * 5个人考试得分分别为 5分，3分，5分，2分，8分;满分是10分; 
 * 要将 5 3 5 2 8 这个数组进行降序排序; 
 * 即排序后变为 8 5 5 3 2; 
 * */  
  
/** 
 * 桶排序解法： 建一个大小为11的一维数组a,a[0]~a[10]元素都初始化为0, 
 * 用元素下标0~10表示分数，用元素的值表示有多少人得过该元素下标对应的分数； 例如： 
 * a[1]=0表示0人得1分，a[5]=2表示有2人得5分，‘5’代表5分，‘2’代表2个人得5分; 
 *  
 * 接下来在a数组的循环中对每个人的分数进行遍历，分数值等于数组下标，该数组的值加1 
 * */  
public class BucketSort {  
  
    public int[] bucketSort(int[] array) {  
        int[] a = new int[11];  
        for (int i = 0; i < a.length; i++) {  
            for (int j = 0; j < array.length; j++) {  
                if (array[j] == i) {  
                    a[i] += 1;  
                }  
            }  
        }  
        return a;  
    }  
  
    public static void main(String[] args) {  
        BucketSort bucket = new BucketSort();  
        int[] array = { 5, 3, 5, 2, 8 };  
        int[] a = bucket.bucketSort(array);  
        for (int i = a.length - 1; i >= 0; i--) {  
            if (a[i] > 0) {  
                for (int j = 0; j < a[i]; j++)  
                    System.out.println(i);  
            }  
        }  
    }  
  
}  

各排序方法的性能的比较

所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

时间复杂度来说：

(1)平方阶(O(n²))排序
　　各类简单排序:直接插入、直接选择和冒泡排序；
 (2)线性对数阶(O(nlog2n))排序
　　快速排序、堆排序和归并排序；
 (3)O(n^1+§))排序,§是介于0和1之间的常数。

       希尔排序
(4)线性阶(O(n))排序
　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。 
     稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则：

每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

1．待排序的记录数目n的大小；

2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

3．关键字的结构及其分布情况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
       堆排序 ：  如果内存空间允许且要求稳定性的，

       归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
　　1、关键字可分解。
　　2、记录的关键字位数较少，如果密集更好
　　3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。