初级排序算法

排序算法类的模板

less()方法对元素进行比较，exch()方法将元素交换位置，show()方法打印数组.这个模板使用任何实现了Comparable接口的数据类型。

代码实现：

public class Example {
private static boolean less(Comparable<Object> a,Comparable<Object> b)
{
    return a.compareTo(b)<0;
}

private static void exch(Comparable<Object> [] ary,int i,int j)
{
    Comparable<Object> temp=ary[i];
    ary[i]=ary[j];
    ary[j]=temp;
    
}

private static void show(Comparable<Object>[] ary)
{
    for(int i=0;i<ary.length;i++)
    {
        System.out.print(ary[i]+" ");
    }
    System.out.println();
}
private static boolean isSorted(Comparable<Object>[] ary)
{
    for(int i=1;i<ary.length;i++)
    {
        if(less(ary[i],ary[i-1]))
            return false;
        
    }
    return true;
}
public static void sort(Comparable<Object>[] ary)
{ 
    
    //各种排序算法
    
    
}
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

选择排序

首先，找到数组中最小的那个元素，其次将他和数组中的第一个元素交换位置（如果他就在第一位就和自己交换位置）。再次在剩下的元素中找到最小的元素，将他与第二个元素交换位置，以此类推，直到将整个数组排序。

代码实现：

        int l=ary.length;
     for(int i=0;i<l;i++)
     {
         int min=i;
         for(int j=i+1;j<l;j++)
         {
             if(less(ary[j],ary[min]))
                 min=j;
         }
         exch(ary,i,min);
     }

选择排序轨迹。

算法分析：

运行时间和输入无关，为找出最小元素进行的扫面不会对下一遍有任何帮助，这样你会发现如果对一个已经排序好的数组再进行选择排序，花费的时间和对无序数组排序花费的时间一样长。

数据移动是最少的，交换次数和数组大小是线性关系。

插入排序：

将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据。当前索引左边的所有元素都是有序的，但最终位置不确定，当索引到达最右端时，排序算法就算完成了。

代码实现：

    int l=ary.length;
    for(int i=1;i<l;i++)
    {
        for(int j=i;j>0&&less(ary[j],ary[j--]);j--)
        {
            exch(ary,j,j-1);
        }
    }

算法分析：

需要的时间取决于输入元素中的初始顺序，例如，当我们对一个已经排序好的数组使用插入排序时，他能立即发现该数组的每个元素都在合适的位置上

算法轨迹。

希尔排序

一种基于插入排序的算法，思想是使数组中任意间隔为H的数组都是有序的，这样的数组称为h有序数组，在进行排序时，如果h很大，就能将元素移动到很远的位置，为实现更小的h创造方便

希尔排序高效的原因在于排序之处，各个子数组都很短，排序之后的子数组都是部分有序的，这两种情况下都很适合插入排序。

 代码实现：

int n=ary.length;
    int h=1;
    while(h<n/3)
        h=3*h+1;//1，4，13.。。。。。。
    while(h>=1)
    {
        for(int i=h;i<n;i++)
        {
            for(int j=i;j>=h&&less(ary[j],ary[j-h]);j-=h)
            {
                exch(ary,j,j-h);
            }
        }
    }

算法轨迹