排序算法的实例

  写了一下排序算法的一些实例，Java语言写的，从网上也是各种找，各种测试，整理了一下，方便学习极客时间专栏-数据结构与算法：作者是王争。

    //二路归并排序中计算排序次数
    public static int number = 0;
    
    /**
     * 冒泡排序的算法  关键是先排列出最大的数 依次从大到小进行排序 
     * 
     * 算法描述：
     * 1.比较相邻的元素，如果第一个比第二个大，就交换它们两个
     * 2.对每一个相邻的元素做同样的工作，从开始的第一队，到结束的最后一对，这样在最后的元素应该是最大的数
     * 3.针对所有的元素重复以上步骤，除了最后一个
     * 4.重复步骤1~3，知道排序完成
     * 
     * @param arr 需要排序的数组元素，这里只针对整数，当然其他的也可以
     * @return
     */
    public int[] bubbleSort(int[] arr){
        
        int len = arr.length;
        
        for(int i=0; i<len-1; i++){
            //其实 len-1-i 说明的是第二个循环每次不用全部循环  只需要循环还没有排列出顺序的数
            for(int j=0; j<len-1-i; j++){
                //相邻两元素 两两对比
                if(arr[j] > arr[j+1]){
                    //元素交换 把大数放在后面 
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp; 
                }
            }
        }
        return arr;
    }
    
    /**
     * 选择排序算法  是一种简单直观的算法，在未排序的序列中找到最小（大）数，存放在数列起始的位置，
     *          然后在从剩余的数列中寻找最小（大），放在已排序数列的末尾
     * 
     * 算法描述：
     * 1.初始状态：无序区为R[1..n]，有序区为空
     * 2.第i（i=1,2,3,..,n）趟排序开始时，当前有序区和无序区分别为R[1..i-1]、R[i..n]，该趟排序从当前无序区中选出关键字最小的记录
     * R[k]，将他和无序区的最后一个R交换，使R[1..i]和R[i+1..n-1]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区
     * 3.n-1趟结束，数据有序化了
     * 
     * @param arr 待排序的整数数组
     * @return 排序完成
     */
    public int[] selectionSort(int[] arr){
        
        int len = arr.length;
        int minIndex;
        int temp;
        
        // arr len=10 最后一个下标即是9
        for(int i=0; i<len-1; i++){
            minIndex = i;
            //j<len 这个不会出现数组越界的问题的因为没有用到 arr[j+1]
            for(int j=i+1; j<len; j++){
                //寻找为排序的数列中最小的数
                if(arr[j] < arr[minIndex]){
                    //将最小的数的索引保存
                    minIndex = j;
                }
            }
            //将两个数交换位置，之后继续排序，直到排序完成
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }
    
    /**
     * 插入排序算法  通过构建有序数列，对于未排序数据，在已排序的序列中从后向前扫描，找到相应的位置并插入
     * 
     * 算法描述：
     * 1.从第一个元素开始，该元素可以被认为已经被排序
     * 2.取出下一个元素，在已经排序的序列中从后向前扫描
     * 3.如果该元素（已排序）大于新元素，将该元素移到下一位置
     * 4.重复步骤三，直到找到已排序的元素小于或者等于新元素的位置
     * 5.将新元素插入到该位置后
     * 6.重复步骤2~5
     * 
     * 问题：
     * 这段排序的程序有点难以理解！！！大概是明白了
     * 
     * @param arr 待排序的整数数组
     * @return 排序完成
     */
    public int[] insertionSort(int[] arr){
        
        int len = arr.length;
        int preIndex;
        int current;
        
        for(int i=1; i<len; i++){
            preIndex = i-1;
            current = arr[i];
            
            //对于preIndex-- 当前的数和已排序数列的数逐次比较大小，在有序数列中找到preIndex下标的数（下标为preIndex的数小于当前数）
            while(preIndex >= 0 && arr[preIndex] > current){
                arr[preIndex+1] = arr[preIndex];
                preIndex--;
            }
            //结束while循环则表示当前数 大于或者等于有序数列中下标为preIndex的一个数，则把当前数 放在这个数的后面
            arr[preIndex+1] = current;
        }
        return arr;
    }
    
    /**
     * 希尔排序  1959年，shell发明，第一个突破O(n*n)的排序算法，是简单插入排序的改进版，它会优先比较较远的元素，又叫缩小增量排序
     * 
     * 算法描述：（先将整个待排序的记录序列分割成若干个子序列分别进行直接插入排序）
     * 1.选择一个增量序列t1,t2,...,tk 其中ti>tj,tk=1;
     * 2.按增量序列个数k，对序列进行K趟排序
     * 3.每趟序列，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对子表进行直接插入排序，
     *        仅增量因子为1时，整个序列最为一个表来处理，表长度即为整个序列的长度
     * 
     * 问题：这个有点难以理解，关键是间隔序列的设定，还有就是时间空间复杂度为啥小于O(n*n)
     * 
     * @param arr 待排序的整数数组
     * @return 排序完成
     */
    public int[] shellSort(int[] arr){
        
//        long startTime=System.currentTimeMillis();   //获取开始时间
//        System.out.println("程序运行开始时间： "+startTime);
        
        int len = arr.length;
        int gap = 1;
        int temp;
        int j;
        
        //动态定义间隔序列
        while(gap < len/3){
            gap = gap * 3 + 1;
        }
        
        for(; gap>0; gap=(int) Math.floor(gap/3)){
            for(int i=gap; i<len; i++){
                temp = arr[i];
                for(j=i-gap; j>0 && arr[j]>temp; j-=gap){
                    arr[j+gap] = arr[j];
                }
                arr[j+gap] = temp;
            }
        }
        return arr;
    }
    
    /**
     * 二路归并排序的算法  归并排序是建立在归并操作上的一种排序算法   先使子序列有序，再使子序列段间有序
     * 
     * 算法描述：
     * 1.将长度为n的序列分成长度为2/n的两个子序列
     * 2.对这两个子序列分别进行归并排序
     * 3.将排序好的子序列合并成一个最终的合并序列
     * 
     * 问题：
     * 这个归并排序算法 对于奇数个数的数组 好像还是有点问题
     * 
     * @param arr 待排序的数组序列
     * @return 排序完成
     */
    public void mergeSort(int[] arr){
        
        System.out.println("开始排序~~~");
        int len = arr.length - 1;
        sort(arr, 0 , len-1);
    }

    private void sort(int[] arr, int left, int right){
        
        if(left >= right){
            return;
        }
        
        int mid = (left + right)/2;
        System.out.println("middle的数是：>>>>>>>>>>>>"+mid);
        //二路归并排序有两个sort 多路归并排序写多个sort就可以了
        sort(arr, left, mid);
        sort(arr, mid+1, right);
        merge(arr, left, mid, right);
        
    }
    
    private void merge(int[] arr, int left, int mid, int right){
        
        int[] tmp = new int[arr.length];
        int r1 = mid + 1;
        int tIndex = left;
        int cIndex = left;
        
        //逐个合并
        while(left <= mid && r1 <= right){
            if(arr[left] < arr[r1]){
                tmp[tIndex++] = arr[left++];
            }else{
                tmp[tIndex++] = arr[r1++];
            }
        }
        
        //将左边剩余 的合并
        while(left <= mid){
            tmp[tIndex++] = arr[left++];
        }
        
        //将右边剩余的合并
        while(r1 <= right){
            tmp[tIndex++] = arr[r1++];
        }
        
        System.out.println("第"+(++number)+"趟排序:	");
        //从临时数组拷贝到原数组
        while(cIndex <= right){
            arr[cIndex] = tmp[cIndex];
            System.out.print(arr[cIndex]+"	");
            cIndex++;
        }
        System.out.println();
    }
    
    /**
     * 快速排序算法：通过一趟排序将待排记录分隔成独立的两部分，其中一部分的关键字均比另一部分的关键字小，
     *             则可分别对这两部分记录继续排序，从而使整个序列有序
     * 
     * 算法描述：快速排序算法采用分治法 把一个串分成两个子串
     * 1.从数列中挑出一个元素，成为“基准”（pivot）
     * 2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）
     *   在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
     * 3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
     * 
     * @param arr 待排序的数组序列
     * @return 排序完成
     */
    public int[] quickSort(int[] arr, int left, int right){
        
        int partitionIndex;
         
        if (left < right) {
            partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex-1);
            quickSort(arr, partitionIndex+1, right);
        }
        return arr;
    }
    
    //快速排序的分区操作
    private int partition(int[] arr, int left, int right) {     
        //分区操作   设定基准值（pivot）
        int pivot = left;                      
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
                index++;
            }       
        }
        int temp = arr[pivot];
        arr[pivot] = arr[index-1];
        arr[index-1] = temp;
        return index-1;
    }
    
    /**
     * 计数排序算法   
     * 计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。
     * 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
     * 
     * 算法描述：
     * 1.找出待排序的最大和最小的数
     * 2.统计数组中的每个值为i的元素出现的次数，存入数组c的第i项
     * 3.对所有的计数累加（从C的第一个元素开始，每一项和前一项相加）
     * 4.反向填充目标数组：将每个元素i放在新数组的第C（i）项，每放一个元素就将c(i)减1
     * 
     * @param arr 待排序的数组
     * @return
     */
    public int[] countingSort(int[] arr){
        
        int cnum =0;        
        for(int i = 0 ; i<arr.length;i++){            
            if(cnum < arr[i]) {
                cnum = arr[i];
            }                        
        }                    
        int[] c = new int[cnum+1];        
        int[] b = new int[arr.length];
        
        for(int i =0; i<c.length; i++){
            c[i]=0;
        }            
                
        for(int i = 0;i<arr.length;i++) {
            c[arr[i]]+=1;    
        }            
                
        for(int i =1;i<c.length;i++) {
            c[i]+=c[i-1];
        }            
                
        for(int i = arr.length-1;i>=0;i--){            
            b[c[arr[i]]-1]=arr[i];            
            c[arr[i]]-=1;        
        }
        return b;
    }
    
    /**
     * 
     * @param arr 待排序的数组
     * @param maxDigit
     * @return
     */
    public int[] radixSort(int[] A){
        int length = A.length;
        
        // 定义每一轮的除数，1,10,100...
        int divisor = 1;

        // 定义了10个桶，以防每一位都一样全部放入一个桶中
        int[][] bucket = new int[10][length];

        // 统计每个桶中实际存放的元素个数
        int[] count = new int[10];

        // 获取元素中对应位上的数字，即装入那个桶
        int digit;

        // 经过4次装通操作，排序完成
        for (int i = 1; i <= 3; i++) {
            // 计算入桶
            for (int temp : A) {
                digit = (temp / divisor) % 10;
                bucket[digit][count[digit]++] = temp;
            }
            // 被排序数组的下标
            int k = 0;
            // 从0到9号桶按照顺序取出
            for (int b = 0; b < 10; b++) {
                // 如果这个桶中没有元素放入，那么跳过
                if (count[b] == 0)
                    continue;
                for (int w = 0; w < count[b]; w++) {
                    A[k++] = bucket[b][w];
                }
                // 桶中的元素已经全部取出，计数器归零
                count[b] = 0;
            }
            divisor *= 10;
        }
        return A;
    }

注释：写到最后越来越难理解，后面的几个算法，基本上都是拷贝的，但是大体的思路是可以理解的，对于时间、空间复杂度分析，还是比较混乱，但是基本上头脑中有了程序优化的一个概念，最重要的一点是二路归并算法的存在一些问题，对于数组的个数为奇数的，总有最后一个数，不参与排序，等跟着专栏学习，看看能不能解决吧，网上的好多方案都不合适。。。（对于堆排序算法和桶排序算法，没有写）

参考的博客有许多，把主要的贴出来吧，望作者见谅

https://www.cnblogs.com/onepixel/articles/7674659.html

这个作者写的有动图的讲解，很形象！
https://www.cnblogs.com/shudonghe/p/3302888.html
https://www.cnblogs.com/haozhengfei/p/29ba40edbf659f2dbc6b429c2818c594.html

下面是测试代码，转载注明出处，谢谢！！！

//测试代码贴出来吧
public static void main(String[] args) {
        Sort sort = new Sort();
        int[] arr = {3,38,5,15,36,26,30,50,29,59,43,62,18};
        
        //sort.bubbleSort(arr);
        //sort.selectionSort(arr);
        //sort.insertionSort(arr);
        //sort.shellSort(arr);
        //sort.mergeSort(arr);
        //sort.quickSort(arr, 0, arr.length-1);
        //int[] arr1 = sort.countingSort(arr);
    
        sort.radixSort(arr);
        
        for(int i=0; i < arr.length; i++){
            System.out.println("第"+(i+1)+"个数是>>>>>>>>>>"+arr[i]);
        }
    }