排序算法总结版

排序算法分类

     选择排序：简单选择排序、堆排序

     插入排序：直接插入排序、二分插入排序和希尔排序

     归并排序：归并排序

     交换排序：冒泡排序、快速排序

     基数排序：基数排序

算法时间和空间复杂度分析

    

                    图1  性能分析

性能具体分析

    O(n^2):直接插入排序，简单选择排序，冒泡排序。

    在数据规模较小时（9W内），直接插入排序，简单选择排序差不多。当数据较大时，冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较，基本上都是稳定的。

    O(nlogn):快速排序，归并排序，希尔排序，堆排序。

    其中，快排是最好的， 其次是归并和希尔，堆排序在数据量很大时效果明显。

排序算法精讲

 选择排序：

    简单选择排序

       思想：每次找出一个当前最小值并放到合适的位置。

       不稳定排序

       1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

       2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

       3）重复第二步，直到所有元素均排序完毕。     

    堆排序

      思想：利用沉降原理不断的调整成大(小)根堆

      不稳定排序 

/**
    针对数组进行排序
    堆是一种重要的数据结构，为一棵完全二叉树, 底层如果用数组存储数据的话，假设某个元素为序号为i(Java数组从0开始,i为0到n-1),如果它有左子树，那么左子树的位置是2i+1，如果有右子树，右子树的位置是2i+2，如果有父节点，父节点的位置是(n-1)/2取整。分为最大堆和最小堆，最大堆的任意子树根节点不小于任意子结点，最小堆的根节点不大于任意子结点。所谓堆排序就是利用堆这种数据结构来对数组排序，我们使用的是最大堆。处理的思想和冒泡排序，选择排序非常的类似，一层层封顶，只是最大元素的选取使用了最大堆。最大堆的最大元素一定在第0位置，构建好堆之后，交换0位置元素与顶即可。堆排序为原位排序(空间小), 且最坏运行时间是O(nlgn)，是渐进最优的比较排序算法。
**/

//初始化建立大根堆
    private static void buildMaxHeap(int[] array){  //初始时建立大根堆
        if(array == null || array.length <= 1){
            return;
        }
        
        int half = array.length/2;
        for(int i = half; i >=0; i--){
            maxHeap(array, array.length, i);
        }
    }

//调整堆，使用沉降法实现大根堆
    private static void maxHeap(int[] array, int heapSize, int index){  //利用沉降法调整堆
        int left = index*2+1;
        int right = index*2+2;
        
        int largest = index;
        if(left < heapSize && array[left] > array[largest]){
            largest = left;
        }
        
        if(right < heapSize && array[right] > array[largest]){
            largest = right;
        }
        
        if(largest != index){  //需要交换位置
            int tmp = array[index];
            array[index] = array[largest];
            array[largest] = tmp;
            
            maxHeap(array, heapSize, largest);
        }
    }

 //堆排序算法
private static void heapSort(int[] array){
        if(array == null || array.length <= 1){
            return;
        }
        
        buildMaxHeap(array);
        
        for(int i = array.length - 1; i > 0; i--){
            int tmp = array[0];
            array[0] = array[i];
            array[i] = tmp;
            
            maxHeap(array, i, 0);
        }
    }

  插入排序   

    直接插入排序

       思想：每次插入一个元素，保持前面子数组的有序性。

       稳定排序

   折半插入排序

       思想：将待排序的记录R[i]插入到已经排序完成的记录子表R[0,1,...i-1]中时，由于该子表已经排序完成，插找插入位置时可以使用"折半查找"实现。

       稳定排序

   希尔排序

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

       1）选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

       2）按增量序列个数k，对序列进行k 趟排序；

       3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

       不稳定排序

    public int[] shellSort(int[] num, int len) {
        // write code here
        if(num == null || len < 2)
            return num;
        
        for(int step = len/2; step >= 1; step = step/2){  //选取希尔排序的间隔
            subShellSort(num, step);
        }
        
        return num;
    }
    
    public void subShellSort(int[] num, int step){
        for(int i = step; i < num.length; i++){
            for(int j = i; j >=step; j-=step){
                if(num[j] < num[j-step]){  //利用冒泡排序进行子序列的排序
                    int tmp = num[j];
                    num[j] = num[j-step];
                    num[j-step] = tmp;
                }
            }
        }
   }

 

归并排序

      思想：将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列 

      稳定排序

public class MergeSort {
    public int[] mergeSort(int[] A, int n) {
        // write code here
        if(n<2){
            return A;
        }
      
        return sort(A,0,A.length-1);
        
    }
    
    public int[] sort(int[] num, int low, int high){
        int mid = (low+high)/2;
        if(low < high){
            sort(num,low,mid);    //排序左边数组
            
            sort(num,mid+1,high);    //排序右边数组
            
            merge(num,low,mid,high);   //归并两边数组
        }
        
        return num;
    }
    
    public void merge(int[] num, int low, int mid, int high){
        int[] tmp = new int[high-low+1];   //建立临时数组
        int i = low, k = mid+1; //左右数组下标
        int j = 0;
        
        while(i<=mid && k<=high){  
            if(num[i]<num[k]){    
                tmp[j++] = num[i++];
            }else{
                tmp[j++] = num[k++];
            }
        }
        
        
        //左边数组剩余元素
        while(i <= mid){
            tmp[j++] = num[i++];
        }
        
        //右边数组剩余元素
        while(k <= high){
            tmp[j++] = num[k++];
        }
        
        //将新数组的值赋予num数组
        for(int k1 = 0; k1<j; k1++){
            num[k1+low] = tmp[k1];
        }
        
    }
}

基数排序

   基数排序

      思想：基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

   桶排序：

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

      稳定排序