排序算法（一）冒泡排序，简单选择排序，直接插入排序，希尔排序

冒泡排序，简单选择排序，直接插入排序是三种复杂度为O(n2)的算法，希尔排序在特殊增量序列的时候可以获得复杂度为O(n3/2)

冒泡排序

1、最简单的排序实现

这里把每个数和这个数之后的每个数比较，大于就交换位置。
缺点：多出了很多次没有用的交换

public class mysort {
    public void sort(int[] array)
    {
        if(array.length<=1) return;
        for(int i=0;i<array.length-1;i++)
        {
            for(int j=i+1;j<array.length;j++)
            {
                if(array[i]>array[j])
                {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

}

2、冒泡排序

从后向前交换相邻的，这样在交换的过程中附带会把略小的交换到前面去
即每次把最小的数交换到前面去，像冒泡一样

public class mysort {
    public void sort(int[] array)
    {
        for(int i=0;i<array.length;i++)
        {
            for(int j=array.length-1;j>i;j--)
            {
                if(array[j]<array[j-1])
                {
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
    }

}

3、冒泡排序改进算法

设置一个flag用于后面的数是否已经排序，如果已经排好（没有交换）则后面的循环不需要再继续

public class mysort {
    public void sort(int[] array)
    {
        boolean hasSorted = false;
        for(int i=0;(i<array.length) && (!hasSorted);i++)
        {
            hasSorted = true;
            for(int j=array.length-1;j>i;j--)
            {
                if(array[j]<array[j-1])
                {
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    hasSorted = false;
                }
            }
        }
    }

}

简单选择排序

和冒泡相比却只交换当前数和后面数中最小的数，减少了交换的次数

public class mysort {
    public void sort(int[] array)
    {
        if(array.length<2) return;
        for(int i=0;i<array.length-1;i++)
        {
            int min = i;
            for(int j=i+1;j<array.length;j++)
            {
                if(array[j]<array[min])
                    min = j;
            }
            if(min!=i)
            {
            int temp = array[min];
            array[min] = array[i];
            array[i] = temp;
            }
        }
    }

}

直接插入排序

基本思想：将新的数不断插入已经排序好的序列中

public class mysort {
    public void sort(int[] array)
    {
        if(array.length<2) return;
        for(int i=1;i<array.length;i++)
        {
            //[0,i-1]是已经从小到大排好序的数组，如果新的数比原本最大的数小，则需插入原数组
            if(array[i]<array[i-1])
            {
                //num为需要插入的新值
                int num = array[i];
                //如果当前数组中的某个数比需要插入的num大，则后移一位
                int j;
                for(j=i-1;(j>=0)&&(array[j]>num);j--)
                {
                        array[j+1] = array[j];
                }
                //插入num
                array[j+1] = num;
            }
        }
    }

}

希尔排序

遍历数组，相隔某个增量比较两个数，前者大于后者则交换，增量不断变小。增量变小的规律目前还是个难题，因为是跳跃式的，算法也不够稳定

public void xier(int[] arr)
    {
        if(arr==null || arr.length==0) return;
        int increment = arr.length;
        int j = 0;
        do{
            increment = increment/3+1;
            for(int i=increment;i<arr.length;i++)
            {
            //将i-incre,i-2incre,...所有的i-n*incre的比arr[i]大的数都像后挪动incre
                int temp = arr[i];
                for(j=i-increment;j>=0 && arr[j]>temp;j-=increment)
                {
                    arr[j+increment] = arr[j];
                }
                arr[j+increment] = temp;
            }

        }
        //必须保证最后一个incrment=1
        while(increment>1);
    }