排序算法思想

选择排序：

从数据中选择最小的一个并排在第一个位置，接下来从余下的数据中选择最小的排在第二个位置，依次类推。。

算法需要N²/2次比较和N次交换

特点：

1）程序运行时间与输入无关：每一次排序都不能为下一次排序提供有用的信息。有序的数组和无序的数组排序所用的时间一样长。

2）数据移动是最少的：两两交换只需交换N次，是所有算法中交换次数最少的

package sort;

public class ChooseSort {

    public static int[] sort(int[] a){
        
        for(int i=0;i<a.length;i++)
        {
            int min=a[i];
            int minIndex=i;
            for(int j=i+1;j<a.length;j++)
            {
                if(a[j]<min)
                {
                min=a[j];
                minIndex=j;
                }
            }
            int temp=a[i];
            a[i]=min;
            a[minIndex]=temp;
        }
        return a;
    }
    
    public static void main(String args[]){
        int a[]={5,3,2,1,4};
        int []b=sort(a);
        for(int i=0;i<b.length;i++)
            System.out.println(b[i]);
    }
}

 

 

插入排序：

   认为左边部分为有序的，每一次都将右边第一个元素放在左边那部分的适当位置，使得左边部分始终有序。而右边第一个元素也就是要插入的元素的位置腾出来之后，左边的所有比要插入元素大的数据会一次向又移。

   平均需要进行N²/4次比较和N²/4次交换，最差的情况需要进行N²/2次比较和N²/2次交换

   特点：

   当数组本身就是一个有序数组时则不需要移动。

   插入排序对于部分有序数组很有效，部分有序数组包括这种情况：数组中每个元素距离他的最终位置都不远

package sort;

public class InsertSort {

    public static int[] sort(int []a){
        for(int i=1;i<a.length;i++)
        {
            int current=a[i];
            for(int j=i;j>0;j--)
            {
                if(a[j]<a[j-1])
                {
                    int temp=a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                }
            }
        }
        return a;
    }
    
    
    public static void main(String args[]){
        int a[]={3,2,1,4,9,5};
        a=sort(a);
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]);
    }
}

 希尔排序：

希尔排序是改进后的插入排序，首先定义一个间隔d，将数组数据进行分组，用插入排序法保证每个分组内是有序的，之后缩减间隔d的值，重新分组排序，直到间隔为1时，即可保证整个数组是有序的。希尔排序充分利用了插入排序的特性，使得部分有序数组的排序性能大幅度提高。

特性：希尔排序适用于大数组，效果明显。但对于间隔d的选择却是一个问题

package sort;

public class ShellSort {

    public static int[] sort(int []a){
        int d=a.length/3;
        while(d>0){
            for(int i=d;i<a.length;i++)
            {
                for(int j=i;j>0;j=j-d)
                {
                if(a[j]<a[j-d])
                {
                    int temp=a[j];
                    a[j]=a[j-d];
                    a[j-d]=temp;
                    
                }
                }
            }
            d--;
        }
        return a;
    }
    public static void main(String args[]){
        int a[]={5,3,1,4,2};
        a=sort(a);
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]);
    }
}

 归并排序：

归并排序分为自顶向下和自底向上两种方法，自顶向下采用的是递归的方法，自底向上则是这样的：首先一个一个元素归并，之后两两归并，接着四四归并。但是归并时第二组的元素个数可能会和第一组不同。

自底向上方法：

package sort;

public class BottomToTopMergeSort {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int a[]={5,3,2,1,4};
      sort(a);
      for(int i=0;i<a.length;i++)
          System.out.println(a[i]);
    }
    
    public static void merge(int[]a,int lo,int mid,int hi){
        int []aux=new int[a.length];
        for(int i=lo;i<=hi;i++)
            aux[i]=a[i];
        int i=lo;
        int j=mid+1;
        for(int k=lo;k<=hi;k++)
        {
            if(i>mid) a[k]=aux[j++];
            else if(j>hi) a[k]=aux[i++];
            else if(aux[i]>aux[j]) a[k]=aux[j++];
            else a[k]=aux[i++];
        }
    }
    public static void sort(int []a){
        int len=a.length;
        for(int size=1;size<len;size=size+size)
        {
            for(int lo=0;lo<len-size;lo+=size+size){
                merge(a,lo,lo+size-1,Math.min(lo+size+size-1, len-1));
            }
        }
    }
    
}

在该方法中，有两个for循环，第一个for循环用来确定归并元素的个数，第一轮是一个一个归并，第二轮是两两归并，第三轮是四四归并。第二个for循环用来进行分组归并，

for(int lo=0;lo<len-size;lo+=size+size)

从标号为0的元素开始，到长度减去归并组中元素个数，每次跨越两个组。

merge(a,lo,lo+size-1,Math.min(lo+size+size-1, len-1));

还有一点需要注意的是，因为最后无法确定还余多少个元素，因此应取长度或者正规个数最小的那个

 

自顶向下递归排序：

package sort;

public class BottomToTopMergeSort {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int a[]={5,3,2,1,4};
      sort(a);
      for(int i=0;i<a.length;i++)
          System.out.println(a[i]);
    }
    
    public static void merge(int[]a,int lo,int mid,int hi){
        int []aux=new int[a.length];
        for(int i=lo;i<=hi;i++)
            aux[i]=a[i];
        int i=lo;
        int j=mid+1;
        for(int k=lo;k<=hi;k++)
        {
            if(i>mid) a[k]=aux[j++];
            else if(j>hi) a[k]=aux[i++];
            else if(aux[i]>aux[j]) a[k]=aux[j++];
            else a[k]=aux[i++];
        }
    }
    public static void sort(int []a){
        int len=a.length;
        for(int size=1;size<len;size=size+size)
        {
            for(int lo=0;lo<len-size;lo+=size+size){
                merge(a,lo,lo+size-1,Math.min(lo+size+size-1, len-1));
            }
        }
    }
    
}