算法学习之一，排序算法

Java排序算法的框架

public class Sort01 {
    public static void sort(Comparable[] a){
        //排序算法
    }
    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    public static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void show(Comparable[] a){
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
    public static boolean isSorted(Comparable[] a){
        for(int i=1;i<a.length;i++)
            if(less(a[i],a[i-1]))   return false;
        return true;
    }

    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        Comparable[] number=new Comparable[10];
        for(int i=0;i<10;i++){
            number[i]=scanner.nextInt();
        }
        sort(number);
       // assert isSorted(number);
        show(number);


    }
}

一 选择排序：

选择排序就是选择最小的值放在最头的元素

举例说就是：

3 5 6 2 1

第一趟：1 3 5 6 2

第二趟：1 2 5 6 3

第三趟：1 2 3 6 5

第四趟：1 2 3 5 6

算法实现：

public static void sort(Comparable[] a){
    for(int i=0;i<a.lenth;i++){
        int min=i;
        for(int j=i+1;j<a.lenth;j++){
            if(less(a[j],a[min]))    min=j;
        }
        exch(a,i,min);
}

输入样例：

3 5 6 2 1

输出样例：

1 2 3 5 6

二 插入排序

插入排序就是选择一个点，如果后面的那个点小于之前的点就交换，当之前的点小于这个点的时候，则选择下一个点，如果是这个序列本来就是顺序的，那么这个排序的复杂度就是线性介，也就是O(n)

实现

poublic static void sort(Comparable[] a){
    for(int i=1;i<a.lenth;i++){
        for(int j=i;j>0&&less(a[j],a[j-1],j--){
            exch(a,j,j-1);
        }
    }
}

插入排序从代码上看比选择排序简单很多而且时间复杂度比选择排序更好一些

基本步骤是将第一个元素作为标志位，然后开始第二个元素比较，之后第二个元素作为标志位，再次比较之前的，当且仅当元素顺序一致的时候，不用执行第二个嵌套的循环，这个 时候的时间复杂度位线性介。

基本顺序大概是这样的：

11 15 41 23 10 4 14 8 74 47

第一趟：11 15 41 23 10 4 14 8 74 47
第二趟：11 15 41 23 10 4 14 8 74 47
第三趟：11 15 23 41 10 4 14 8 74 47
第四趟：10 11 15 23 41 4 14 8 74 47
第五趟：4 10 11 15 23 41 14 8 74 47
第六趟：4 10 11 14 15 23 41 8 74 47
第七趟：4 8 10 11 14 15 23 41 74 47
第八趟：4 8 10 11 14 15 23 41 74 47
第九趟：4 8 10 11 14 15 23 41 47 74
第十趟：4 8 10 11 14 15 23 41 47 74

以上排序结果都是程序输出的，我们发现前三次结果没有什么变化因为前三次是顺序的，所以第二个循环就没有执行。

三 希尔排序

希尔排序就是选择一定间隔的元素比较大小，将h个数组独立排序

希尔排序的实现：

public static void ShellSort(Comparable[] a){
    int h=1;
    while(h<a.length/3)    h=3*h+1;
    while(h>=1){
        for(int i=h;i<a.length;i++){
            for(int j=i;j>=h&&less(a[j],a[j-h]);j-=h){
                exch(a,j,j-h);
            }
        }
    h/=3;
}

11 15 41 23 10 4 14 8 74 47
第1趟:10 15 41 23 11 4 14 8 74 47
第2趟:10 4 41 23 11 15 14 8 74 47
第3趟:10 4 14 23 11 15 41 8 74 47
第4趟:10 4 14 8 11 15 41 23 74 47
第5趟:4 10 14 8 11 15 41 23 74 47
第6趟:4 10 8 14 11 15 41 23 74 47
第7趟:4 8 10 14 11 15 41 23 74 47
第8趟:4 8 10 11 14 15 41 23 74 47
第9趟:4 8 10 11 14 15 23 41 74 47
第10趟:4 8 10 11 14 15 23 41 47 74

排序大概是这样。

--------------------------------4月17日更新--------------------------------------------

Python语言基本排序总结：

冒泡排序：

#冒泡排序
number=[5,7,9,1,3,2,0]
for k in range(1,number.__len__()):
    for i in range(0,number.__len__()-k):
        if number[i]>number[i+1]:
            temp=number[i]
            number[i]=number[i+1]
            number[i+1]=temp
print number

选择排序：

#选择排序
number=[5,7,9,1,3,2,0]
for k in range(1,number.__len__()):
    for i in range(0,number.__len__()):
        if number[k]<number[i]:
            temp=number[i]
            number[i]=number[k]
            number[k]=temp
print number

快速排序：

#快速排序
number=[5,7,9,1,3,2,0]
def thesort(low,high,a):
    first = low
    last = high
    if first>=last:
        return
    key = a[first]
    while first<last:
        while first<last and a[last]>=key:
            last=last-1
        a[first]=a[last]
        while first<last and a[first]<=key:
            first=first+1
        a[last]=a[first]
    a[first]=key
    thesort(low,first-1,a)
    thesort(first+1,high,a)
thesort(0,6,number)
print number