冒泡排序-直接选择排序-直接插入排序-希尔排序-java实现

个人总结了4种简单的排序算法,使用java语言实现
类命名有些奇葩,主要是方便读者阅读

冒泡排序算法

冒泡排序是一种用时间换空间的排序方法，最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序。在这种情况下，每一次比较都需要进行交换运算

比如 一个数列 5 4 3 2 1 进行冒泡升序排列，第一次大循环从第一个数（5）开始到倒数第二个数（2）结束，比较过程：先比较5和4，4比5小，交换位置变成4 5 3 2 1；比较5和3，3比5小，交换位置变成4 3 5 2 1……最后比较5和1，1比5小，交换位置变成4 3 2 1 5。这时候共进行了4次比较交换运算，最后1个数变成了数列最大数。
第二次大循环从第一个数（4）开始到倒数第三个数（2）结束。进行3次比较交换运算。
……
所以总的比较次数为 4 + 3 + 2 + 1 = 10次

对于n位的数列则有比较次数为 (n-1) + (n-2) + … + 1 = n * (n - 1) / 2，这就得到了最大的比较次数
而O(N^2)表示的是复杂度的数量级

冒泡排序总的平均时间复杂度为 O(N^2)

//冒泡排序算法
public class MaoPao {

    public static void main(String[] args) {        
        int arr[] = {12,2,16,30,28,10,16,20,6,18};
        show(arr);
        sort(arr);
        show(arr);
    }

    //排序算法-冒泡
    private static void sort(int arr[]){
        int len = arr.length - 1;
        int temp ;
        for(int i = 0; i < len; i++){
            for (int j = 0; j < len - i ; j++){
                if(arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //格式化输出
    private static void show(int arr[]){
        int len = arr.length;
        for(int i = 0; i < len - 1; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println(arr[len - 1]);
    }
}

由于main方法和show()方法内容差不多 下边给大家提供 最核心的排序方法

排序算法-选择

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最前（最后），直到全部待排序的数据元素排完。选择排序是不稳定的排序方法( 因为数据元素有重复的,排序过后重复值会交换位置,所以就破坏了之前的顺序)

比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+…+1=n*(n-1）/2。

交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

private static void sort(int arr[]){
        int len = arr.length - 1;
        int temp ;  //临时数据
        int index = 0;  //下标
        for(int i = 0; i < len; i++){
            index = 0;
            for (int j = 1; j <= len - i ; j++){
                if(arr[j] > arr[index]){
                    index = j;
                }
            }
            temp = arr[index];
            arr[index] = arr[len - i];
            arr[len - i] = temp;    
        }
    }

排序算法-插入排序

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入. 是稳定的排序方法。

时间复杂度为O(n^2)
空间复杂度O(1)
最好情况：正序，不需要移动元素

插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。

private static void sort(int arr[]){
        int i,j,temp,index;
        int len = arr.length;
        for(i = 1; i < len; i++){
            temp = arr[i];
            index = i;
            for(j = i - 1; j >= 0 ; j--){
                if(arr[j] > temp){
                    arr[j + 1] = arr[j];
                    index = j;
                }               
            }
            arr[index] = temp;
        }
    }   

排序算法-希尔

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。

希尔排序是非稳定排序算法

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

希尔算法在最坏的情况下和平均情况下执行效率相差不是很多

空间复杂度：O(1)
时间复杂度小于O(n^2) 可以理解为O(n1.3)

private static void sort(int arr[]){
        int i,j,temp,index;
        int len = arr.length;
        int k = len / 2; 
        while(k > 0){
            for(i = k; i < len; i++){
                temp = arr[i];
                index = i;
                for(j = i - k; j >= 0 ; j -= k){
                    if(arr[j] > temp){
                        arr[j + k] = arr[j];
                        index = j;
                    }               
                }
                arr[index] = temp;
            }
            k /=2;
        }
    }