Java排序算法学习

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

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

 

 

1、每个算法的思想是什么？ 
     2、每个算法的稳定性怎样？时间复杂度是多少？ 
     3、在什么情况下，算法出现最好情况 or 最坏情况？ 
     4、每种算法的具体实现又是怎样的？

     这个是排序算法里面最基本，也是最常考的问题。下面是我的小结。

2、各算法的思想

 

冒泡排序是稳定的，算法时间复杂度是O(n ^2)。  

 2.2 选择排序（Selection Sort）   

选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置已经是正确的了。   选择排序是不稳定的，算法复杂度是O(n ^2 )。   

2.3 插入排序 （Insertion Sort）   

插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i] 又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。   直接插入排序是稳定的，算法时间复杂度是O(n ^2) 。  

2.4 堆排序   

堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。   堆排序是不稳定的，算法时间复杂度O(nlog n)。   

2.5 归并排序   

设有两个有序（升序）序列存储在同一数组中相邻的位置上，不妨设为A[l..m]，A[m+1..h]，将它们归并为一个有序数列，并存储在A[l..h]。   其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。   

2.6 快速排序   

快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。   快速排序是不稳定的，最理想情况算法时间复杂度O(nlog2n)，最坏O(n ^2)。  

2.7 希尔排序  

在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为 增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。  希尔排序是不稳定的，其时间复杂度为O(n ^2)。

（1）--冒泡排序的算法实现如下:【排序后，数组从小到大排列】

/** * 冒泡排序 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 * 针对所有的元素重复以上的步骤，除了最后一个。 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 * @param numbers 需要排序的整型数组 */ public static void bubbleSort(int[] numbers) { int temp = 0; int size = numbers.length; for(int i = 0 ; i < size-1; i ++) { for(int j = 0 ;j < size-1-i ; j++) { if(numbers[j] > numbers[j+1]) //交换两数位置 { temp = numbers[j]; numbers[j] = numbers[j+1]; numbers[j+1] = temp; } } } }

（2）插入排序--直接插入排序

排序思路：每次将一个待排序的元素与已排序的元素进行逐一比较，直到找到合适的位置按大小插入。

public static void insertsort(int arr[]){                
        for(int i = 1;i < arr.length; i ++){
            if(arr[i] < arr[i-1]){//注意[0,i-1]都是有序的。如果待插入元素比arr[i-1]还大则无需再与[i-1]前面的元素进行比较了，反之则进入if语句
                int temp = arr[i];
                int j;
                for(j = i-1; j >= 0 && arr[j] > temp; j --){                
                        arr[j+1] = arr[j];//把比temp大或相等的元素全部往后移动一个位置            
                }
// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
                arr[j+1] = temp;//把待排序的元素temp插入腾出位置的(j+1)
            }            
        }
        
    }
        
    public static void main(String[] args) {
        int array[] = {4,2,1,5};
        
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element+" ");
        }
        
        insertsort(array);
        System.out.println("\n排序之后：");        
        for(int element : array){
            System.out.print(element+" ");
        }
    }
}

 

算法分析：1.当元素的初始序列为正序时，仅外循环要进行n-1趟排序且每一趟只进行一次比较，没有进入if语句不存在元素之间的交换(移动)。此时比较次数(Cmin)和移动次数(Mmin)达到                  最小值。

                 Cmin = n-1    Mmin = 0;

                此时时间复杂度为O(n)。

              2.当元素的初始序列为反序时，每趟排序中待插入的元素都要和[0,i-1]中的i个元素进行比较且要将这i个元素后移(arr[j+1] = arr[j])，i个元素后移移动次数当然也就为i                    了，再加上temp = arr[i]与arr[j+1] = temp的两次移动，每趟移动的次数为i+2,此时比较次数(Cmin)和移动次数(Mmin)达到最小值。

                 Cmax = 1+2+...+(n-1) = n*(n-1)/2 = O(n2)

                 Mmax = (1+2)+(2+2)+...+(n-1+2) = (n-1)*(n+4)/2 = O(n2)  (i取值范围1~n-1)

                 此时时间复杂度为O(n2)。

              3.在直接插入排序中只使用了i,j,temp这3个辅助元素，与问题规模无关，所以空间复杂度为O(1).

              4.在整个排序结束后，即使有相同元素它们的相对位置也没有发生变化，

                  如：5,3,2,3排序过程如下

                     A--3,5,2,3

                     B--2,3,5,3

                     C--2,3,3,5

                   排序结束后两个元素3的相对位置没有发生改变，所以直接插入排序是一种稳定排序。

 

 

 

 

（3）选择排序--简单选择排序

排序思路：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环。

public static void selectSort(int arr[]){ int temp; for(int i = 0;i < arr.length-1; i ++){//有N个元素只需比较N-1次 int min = i;//记住初始位置 for(int j = i+1; j < arr.length; j ++){//在 [i+1,arr.length) 中选最小元素，注意这里的i+1和arr.lenth均为元素下标 if(arr[j] < arr[min]) min = j;//min记下目前找到的最元素的下标 if(min != i){ //每趟比较中元素之间只进行一次交换，即元素移动3次。 temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } } } } public static void main(String[] args) { int array[] = {2,1,1,5,2}; System.out.println("排序之前："); for(int element : array){ System.out.print(element+" "); } selectSort(array); System.out.println("\n排序之后"); for(int element : array){ System.out.print(element+" "); } } }

算法分析：1.在选择排序中，无论元素的初始序列如何，都要进行 (n-1)+(n-2)+(n-3)+....+1 = n*(n-1)/2 = O(n2)次比较，所以时间复杂度为O(n2) n为元素个数

              2.当元素的初始序列为正序时，移动次数为0，而当元素的初始序列为反序时，总的移动次数为：3*总趟数，即Mmax  = 3*(n-1) 

              3.在直接选择排序中只使用了i,j,min这3个辅助元素，与问题规模无关，所以空间复杂度为O(1).

              4.当元素序列类似[8,5,8,1]时，在第一趟比较中第一个元素8和最后个元素1进行了交换，元素中的两个8的相对位置发生了改变，所以直接选择排序是一种不稳定排序。

（4）

插入排序--折半插入排序

排序思路：通过折半查找的方式找到合适的插入位置再插入。

public class BiInsertSort {
    public static void biInsertSort(int arr[]){
        for(int i = 1; i < arr.length; i ++){
            int temp = arr[i];
            int left = 0;
            int right = i-1;
            while(left <= right){//通过拆装查找找到插入位置
                int mid = (left+right)/2;
                if(temp < arr[mid]){//插入点在[left,mid-1]
                    right = mid-1;
                }else               //插入点在[mid+1,right]
                    left = mid+1;
            }//直到找到合适的位置（left或right+1），接下来就将left/right+1后的元素后移
            for(int j = i-1;j >= right+1; j --){
                arr[j+1] = arr[j];
            }
            arr[right+1] = temp;
        }        
    }
    public static void main(String[] args) {
        int array[] = {2,5,3,1,5,2,8};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element+" ");
        }        
        biInsertSort(array);
        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element+" ");
        }
    }
}

算法分析：不管元素的初始序列为正序还是反序，其时间复杂度都和直接插入排序的一样为O(n2)。不同的是折半插入排序中查找的平均比较次数为log2(i+1)-1,

              所以就平均性能而言，折半插入排序优于直接插入排序。

              同样，折半插排序的空间复杂度也是O(1),且也是一种稳定的排序。

（5）图解快速排序

快速排序是冒泡排序的改进版，也是最好的一种内排序，在很多面试题中都会出现，也是作为程序员必须掌握的一种排序方法。

思想:1.在待排序的元素任取一个元素作为基准(通常选第一个元素，但最的选择方法是从待排序元素中随机选取一个作为基准)，称为基准元素；

       2.将待排序的元素进行分区，比基准元素大的元素放在它的右边，比其小的放在它的左边；

       3.对左右两个分区重复以上步骤直到所有元素都是有序的。

所以我是把快速排序联想成东拆西补或西拆东补，一边拆一边补，直到所有元素达到有序状态。

下面再看看示图理解下吧：

 

 

 

public class QuickSort {

    public static void quickSort(int arr[],int _left,int _right){
        int left = _left;
        int right = _right;
        int temp = 0;
        if(left <= right){   //待排序的元素至少有两个的情况
            temp = arr[left];  //待排序的第一个元素作为基准元素
            while(left != right){   //从左右两边交替扫描，直到left = right

                while(right > left && arr[right] >= temp)  
                     right --;        //从右往左扫描，找到第一个比基准元素小的元素
                  arr[left] = arr[right];  //找到这种元素arr[right]后与arr[left]交换

                while(left < right && arr[left] <= temp)
                     left ++;         //从左往右扫描，找到第一个比基准元素大的元素
                  arr[right] = arr[left];  //找到这种元素arr[left]后，与arr[right]交换

            }
            arr[right] = temp;    //基准元素归位
            quickSort(arr,_left,left-1);  //对基准元素左边的元素进行递归排序
            quickSort(arr, right+1,_right);  //对基准元素右边的进行递归排序
        }        
    }
    public static void main(String[] args) {
        int array[] = {10,5,3,1,7,2,8};
        System.out.println("排序之前：");
        for(int element : array){
            System.out.print(element+" ");
        }
        
        quickSort(array,0,array.length-1);

        System.out.println("\n排序之后：");
        for(int element : array){
            System.out.print(element+" ");
        }

    }

}

算法分析：1.当分区选取的基准元素为待排序元素中的最大或最小值时，为最坏的情况，时间复杂度和直接插入排序的一样，移动次数达到最大值

                  Cmax = 1+2+...+(n-1) = n*(n-1)/2 = O(n2) 此时最好时间复杂为O(n2) 

              2.当分区选取的基准元素为待排序元素中的"中值"，为最好的情况，时间复杂度为O(nlog2n)。

              3.快速排序的空间复杂度为O(log2n). 

              4.当待排序元素类似[6,1,3,7,3]且基准元素为6时，经过分区，形成[1,3,3,6,7],两个3的相对位置发生了改变，所是快速排序是一种不稳定排序。

 

 

 

 

 

 

参考文章：http://geniuszhe.blog.163.com/blog/static/11934682011101101434605/

              http://www.cnblogs.com/MOBIN/p/4681369.html

          http://www.cnblogs.com/0201zcr/p/4764427.html