原文:http://blog.csdn.net/t12x3456/article/details/7430700

各种排序算法:冒择路(入)兮(稀)快归堆,桶式排序,基数排序

冒泡排序,选择排序,插入排序,稀尔排序,快速排序,归并排序,堆排序,桶式排序,基数排序

一、冒泡排序(BubbleSort)
1. 基本思想:
  两两比较待排序数据元素的大小,发现两个数据元素的次序相反时即进行交换,直到没有反序的数据元素为止。
2. 排序过程:
  设想被排序的数组R[1..N]垂直竖立,将每个数据元素看作有重量的气泡,根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R,凡扫描到违反本原则的轻气泡,就使其向上"漂浮",如此反复进行,直至最后任何两个气泡都是轻者在上,重者在下为止。
【示例】:
49 13 13 13 13 13 13 13 
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97

java代码实现:

/**  
* 冒泡排序:执行完一次内for循环后,最小的一个数放到了数组的最前面(跟那一个排序算法* 不一样)。相邻位置之间交换  
*/    
    
public class BubbleSort {       
      
    /**    
     * 排序算法的实现,对数组中指定的元素进行排序    
     * @param array 待排序的数组    
     * @param from 从哪里开始排序    
     * @param end 排到哪里    
     * @param c 比较器    
     */      
    public void bubble(Integer[] array, int from, int end) {       
        //需array.length - 1轮比较       
        for (int k = 1; k < end - from + 1; k++) {       
            //每轮循环中从最后一个元素开始向前起泡,直到i=k止,即i等于轮次止       
            for (int i = end - from; i >= k; i--) {       
                //按照一种规则(后面元素不能小于前面元素)排序       
                if ((array[i].compareTo(array[i - 1])) < 0) {       
                    //如果后面元素小于了(当然是大于还是小于要看比较器实现了)前面的元素,则前后交换       
                    swap(array, i, i - 1);       
                }       
            }       
        }       
    }       
        
    /**    
     * 交换数组中的两个元素的位置    
     * @param array 待交换的数组    
     * @param i 第一个元素    
     * @param j 第二个元素    
     */      
    public void swap(Integer[] array, int i, int j) {       
        if (i != j) {//只有不是同一位置时才需交换       
            Integer tmp = array[i];       
            array[i] = array[j];       
            array[j] = tmp;       
        }       
    }       
    
        
    /**     
    * 测试     
    * @param args     
    */      
    public static void main(String[] args) {       
        Integer[] intgArr = { 7, 2, 4, 3, 12, 1, 9, 6, 8, 5, 11, 10 };       
        BubbleSort bubblesort = new BubbleSort();       
        bubblesort.bubble(intgArr,0,intgArr.length-1);    
        for(Integer intObj:intgArr){    
            System.out.print(intObj + " ");    
        }    
    }       
}


另外一种实现方式:

/** 
冒泡排序:执行完一次内for循环后,最大的一个数放到了数组的最后面。相邻位置之间交换 
*/  
public class BubbleSort2{  
    public static void main(String[] args){  
        int[] a = {3,5,9,4,7,8,6,1,2};  
        BubbleSort2 bubble = new BubbleSort2();  
        bubble.bubble(a);  
        for(int num:a){  
            System.out.print(num + " ");  
        }  
    }  
      
    public void bubble(int[] a){  
        for(int i=a.length-1;i>0;i--){  
            for(int j=0;j<i;j++){  
                if(new Integer(a[j]).compareTo(new Integer(a[j+1]))>0){  
                    swap(a,j,j+1);  
                }  
            }  
        }  
    }  
      
    public void swap(int[] a,int x,int y){  
        int temp;  
        temp=a[x];  
        a[x]=a[y];  
        a[y]=temp;  
    }  
}

 

二、选择排序
1. 基本思想:
  每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
2. 排序过程:
【示例】:
  初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 [38 65 97 76 49 27 49]
第二趟排序后 13 27 [65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [49 97 65 76]
第五趟排序后 13 27 38 49 49 [97 97 76]
第六趟排序后 13 27 38 49 49 76 [76 97]
第七趟排序后 13 27 38 49 49 76 76 [ 97]
最后排序结果 13 27 38 49 49 76 76 97

java代码实现:

/**  
* 简单选择排序:执行完一次内for循环后最小的一个数放在了数组的最前面。  
*/    
public class SelectSort {       
      
    /**    
     * 排序算法的实现,对数组中指定的元素进行排序    
     * @param array 待排序的数组    
     * @param from 从哪里开始排序    
     * @param end 排到哪里    
     * @param c 比较器    
     */      
    public void select(Integer[] array) {       
        int minIndex;//最小索引       
        /*    
         * 循环整个数组(其实这里的上界为 array.length - 1 即可,因为当 i= array.length-1    
         * 时,最后一个元素就已是最大的了,如果为array.length时,内层循环将不再循环),每轮假设    
         * 第一个元素为最小元素,如果从第一元素后能选出比第一个元素更小元素,则让让最小元素与第一    
         * 个元素交换     
         */      
        for (int i=0; i<array.length; i++) {       
            minIndex = i;//假设每轮第一个元素为最小元素       
            //从假设的最小元素的下一元素开始循环       
            for (int j=i+1;j<array.length; j++) {       
                //如果发现有比当前array[smallIndex]更小元素,则记下该元素的索引于smallIndex中       
                if ((array[j].compareTo(array[minIndex])) < 0) {       
                    minIndex = j;       
                }       
            }       
      
            //先前只是记录最小元素索引,当最小元素索引确定后,再与每轮的第一个元素交换       
            swap(array, i, minIndex);       
        }       
    }       
        
    public static void swap(Integer[] intgArr,int x,int y){    
        //Integer temp; //这个也行    
        int temp;    
        temp=intgArr[x];    
        intgArr[x]=intgArr[y];    
        intgArr[y]=temp;    
    }    
        
    /**    
     * 测试    
     * @param args    
     */      
    public static void main(String[] args) {       
        Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7 };       
        SelectSort insertSort = new SelectSort();    
        insertSort.select(intgArr);    
        for(Integer intObj:intgArr){    
            System.out.print(intObj + " ");    
        }      
            
    }       
}


三、插入排序(Insertion Sort)
1. 基本思想:
  每次将一个待排序的数据元素,插入到前面已经排好序的数列中的适当位置,使数列依然有序;直到待排序数据元素全部插入完为止。
2. 排序过程:  
【示例】:
[初始关键字] [49] 38 65 97 76 13 27 49
    J=2(38) [38 49] 65 97 76 13 27 49
    J=3(65) [38 49 65] 97 76 13 27 49
    J=4(97) [38 49 65 97] 76 13 27 49
    J=5(76) [38 49 65 76 97] 13 27 49
    J=6(13) [13 38 49 65 76 97] 27 49
    J=7(27) [13 27 38 49 65 76 97] 49
    J=8(49) [13 27 38 49 49 65 76 97] 

java代码实现:

/**
* 直接插入排序:
* 注意所有排序都是从小到大排。
*/ 
 
public class InsertSort {    
   
    /** 
     * 排序算法的实现,对数组中指定的元素进行排序 
     * @param array 待排序的数组 
     * @param from 从哪里开始排序 
     * @param end 排到哪里 
     * @param c 比较器 
     */   
    public void insert(Integer[] array,int from, int end) {    
   
        /* 
         * 第一层循环:对待插入(排序)的元素进行循环 
         * 从待排序数组断的第二个元素开始循环,到最后一个元素(包括)止 
         */   
        for (int i=from+1; i<=end; i++) {    
            /* 
             * 第二层循环:对有序数组进行循环,且从有序数组最第一个元素开始向后循环 
             * 找到第一个大于待插入的元素 
             * 有序数组初始元素只有一个,且为源数组的第一个元素,一个元素数组总是有序的 
             */   
            for (int j =0; j < i; j++) {    
                Integer insertedElem = array[i];//待插入到有序数组的元素   
                //从有序数组中最一个元素开始查找第一个大于待插入的元素   
                if ((array[j].compareTo(insertedElem)) >0) {    
                    //找到插入点后,从插入点开始向后所有元素后移一位   
                    move(array, j, i - 1);    
                    //将待排序元素插入到有序数组中   
                    array[j] = insertedElem;    
                    break;    
                }    
            }    
        } 
         
        //=======以下是java.util.Arrays的插入排序算法的实现    
        /* 
         * 该算法看起来比较简洁一j点,有点像冒泡算法。 
* 将数组逻辑上分成前后两个集合,前面的集合是已经排序好序的元素,而后面集合为待排序的
         * 集合,每次内层循从后面集合中拿出一个元素,通过冒泡的形式,从前面集合最后一个元素开 
         * 始往前比较,如果发现前面元素大于后面元素,则交换,否则循环退出 
         *  
         * 总感觉这种算术有点怪怪,既然是插入排序,应该是先找到插入点,而后再将待排序的元素插 
         * 入到的插入点上,那么其他元素就必然向后移,感觉算法与排序名称不匹,但返过来与上面实 
         * 现比,其实是一样的,只是上面先找插入点,待找到后一次性将大的元素向后移,而该算法却 
         * 是走一步看一步,一步一步将待排序元素往前移 
         */   
        /* 
        for (int i = from; i <= end; i++) { 
            for (int j = i; j > from && c.compare(array[j - 1], array[j]) > 0; j--) { 
                swap(array, j, j - 1); 
            } 
        } 
        */   
    }    
     
     
     /** 
     * 数组元素后移 
     * @param array 待移动的数组 
     * @param startIndex 从哪个开始移 
     * @param endIndex 到哪个元素止 
     */   
    public void move(Integer[] array,int startIndex, int endIndex) {    
        for (int i = endIndex; i >= startIndex; i--) {    
            array[i+1] = array[i];    
        }    
    }    
 
     
    /** 
     * 测试 
     * @param args 
     */   
    public staticvoid main(String[] args) {    
        Integer[] intgArr = { 5, 9, 1, 4, 2, 6, 3, 8, 0, 7 };    
        InsertSort insertSort = new InsertSort();    
        insertSort.insert(intgArr,0,intgArr.length-1); 
        for(Integer intObj:intgArr){ 
            System.out.print(intObj + " "); 
        } 
    }    
}


四、稀尔排序

java代码实现:

/**  
* 插入排序----希尔排序:我们选择步长为:15,7,3,1  
* 我们选择步长公式为:2^k-