经典排序算法---基于Java实现

1.概述

       这篇博客主要是讲基于java实现的一些排序算法啦，冒泡、选择、插入等等排序算法

2.算法实现

      2.1 冒泡排序

（1）排序思想

    冒泡排序主要就是从前往后一步步冒泡，比较相邻元素，如果相邻元素大就交换，直至完全比较结束，每一趟都有一个元素排在最终的位置上。

（2）代码展示

主要有三个方法：sort()用于排序，exchang()用于两个元素的交换，greater()方法用于比较大小

public class Bubble  {
    public static void sort(Comparable[] a){
        /***
         * 从前往后控制
         * 每一趟都是最大的在最终位置上
         */
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                /***
                 * 如果a[j]>a[j+1]
                 * 就交换两个位置
                 */
                if(greater(a[j],a[j+1])){
                    exchange(a,j,j+1);
                }
            }
        }
    }

    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

    /***
     * 比较大小
     * @param comparable
     * @param comparable1
     * @return
     */
    private static boolean greater(Comparable comparable, Comparable comparable1) {
        //大于0表示comparable>comparable1
        return comparable.compareTo(comparable1)>0;
    }

（3）时间复杂度分析

在冒泡排序中主要是比较和交换的所需时间进行分析，在最坏的情况下：

需要比较：

需要交换的次数与需要比较的系数一致

两者相加就是最终需要的时间，时间复杂度为

2.2 插入排序

（1）排序思想

      插入排序其实就是将排序数列分为已经排序好的部分和未排序好的部分，将索引为j的元素插入已经排序好的部分即索引为[0,j]的部分数组。

（2）代码展示，也是三个api（与冒泡排序一致）

package com.example.algorithm.sort;


/***
 * 插入排序
 */
public class Insert {
    public static void sort(Comparable[] a){
        /***
         * 利用i指定未排序的数字
         * [0,i]是已经排序好的
         */
        for(int i=1;i<a.length;i++){
            //在[0,i]范围内进行插入
            for(int j=i;j>0;j--){
                if(greater(a[j-1],a[j])){
                    exchange(a,j,j-1);
                }
            }
        }
    }

    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

    /***
     * 比较大小
     * @param comparable
     * @param comparable1
     * @return
     */
    private static boolean greater(Comparable comparable, Comparable comparable1) {
        //大于0表示comparable>comparable1
        return comparable.compareTo(comparable1)>0;
    }
}

（3）时间复杂度分析

还是比较和交换元素的时间开销，在最坏的情况下就是逆序排列，比较和交换的次数与冒泡一致。

2.3 选择排序

（1）排序思想

    选择排序就是在未排好序的部分每次选择最小的元素与未排好序的部分的第一个元素进行交换，算法的关键点在于找到最小元素的索引，每次排序都有一个元素在最终位置上。

  与冒泡排序的区别在于：是每次排序只用交换一次，找到最小元素才交换，不是每比较一次就交换一次。

（2）代码展示

也是三个Api，与上述一致，主要是点在于利用一个索引找到最小元素

package com.example.algorithm.sort;

/***
 * 选择排序
 * 利用下标去寻找
 */
public class Selection {
    public static void sort(Comparable[] a){
       for(int i=0;i<a.length-1;i++) {
           int minIndex = i;
           for (int j = i + 1; j < a.length; j++) {
               if (greater(a[minIndex], a[j])) {
                   minIndex = j;  //找到最小值的数组下标
               }
           }
           exchange(a,minIndex,i);  //交换
       }
    }

    /***
     * 交换
     * @param a
     * @param i
     * @param j
     */
    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

    /***
     * 比较大小
     * @param comparable
     * @param comparable1
     * @return
     */
    private static boolean greater(Comparable comparable, Comparable comparable1) {
        //大于0表示comparable>comparable1
        return comparable.compareTo(comparable1)>0;
    }
}

（3）时间复杂度分析

比较次数：

交换次数：n-1

两者相加为时间复杂度

3.总结

   主要是写了冒泡、选择、插入排序的实现，希尔、归并、快排的实现放在（二）里面写啦，先体会一遍思想，然后按照代码敲一遍，手动模拟一遍就Ok啦