排序算法总结

内排序主要类型：

各排序算法比较：

 选择合适的排序方法应综合考虑以下因素：

1、待排序的记录数目n

2、记录的大小（规模）

3、关键字的结构及其初始状态

4、对稳定性的要求

5、语言工具的条件

6、存储结构

7、时间和辅助空间的复杂度等

不同条件下，排序算法的选择：

1、若n较小（n<50）可采用直插法和简单选择法

2、若文件初始状态基本有序（正序），则应选用直插法、冒泡或随机的快速排序为宜

3、若n较大、则应采用时间复杂度为o(nlgn)的排序方法：堆排序、归并排序、快速排序

　  快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布的，快速排序的平均时间最短

     堆排序需要的辅助空间少于快速排序，并且不会出现快排可能出现的最坏情况

希尔排序

package com.flyoung;

public class TestShell {

    public static void shellSort(int[] array){
        int i,j;
        int increment = array.length-1;
        do{
            increment = increment/3+1;
            for(i=increment+1;i<=array.length-1;i++){
                if(array[i]<array[i-increment]){
                    array[0]=array[i];
                    for(j=i-increment;j>0&&array[0]<array[j];j-=increment){
                        array[j+increment]=array[j];
                    }
                    array[j+increment]=array[0];
                }
            }
        }while(increment>1);
        
    }
    public static void main(String[] args) {
        int[] a = {0,9,1,5,8,3,7,4,6,2};
        shellSort(a);
        for(int i=1;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }
    }

}

简单选择排序

package com.flyoung;

public class TestSelect {

    public static void selectSort(int[] array){
        int i,j,min;
        for(i=0;i<array.length-1;i++){
            min=i;
            for(j=i+1;j<=array.length-1;j++){
                if(array[min]>array[j]){
                    min=j;
                }
            }
            if(min!=i){
                swap(array,i,min);
            }
        }
        
    }
    public static void swap(int[] array,int i,int j){
        int temp;
        temp=array[i];
        array[i]=array[j];
        array[j]=temp;
        
    }
    public static void main(String[] args) {
        int[] a = {20,10,30,40,90,100,80,60,50,70};
        selectSort(a);
        for(int i=0;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }
    }
}

堆排序

package com.flyoung;

public class TestHeap {
    
    public static void heapAjust(int[] array,int s,int m){
        int temp,j;
        temp = array[s];
        for(j=2*s;j<=m;j*=2){
            if(j<m&&array[j]<array[j+1]){          //比较左右孩子结点
                ++j;
            }
            if(temp>=array[j]){
                break;
            }
            array[s]=array[j];                  //交换结点值
            s=j;    
        }
        array[s]=temp;
        
    }
    
    public static void heapSort(int[] array){
        int i;
        for(i=(array.length-1)/2;i>0;i--){            //建堆
            heapAjust(array,i,array.length-1);
        }
        for(i=array.length-1;i>1;i--){                    //根节点和最后一个结点交换，再调整
            swap(array,1,i);
            heapAjust(array,1,i-1);
        }
    }
    public static void swap(int[] a,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    public static void main(String[] args) {
        int [] a={0,3,2,4,1,5,7,9,8,6};
        heapSort(a);
        for(int i=1;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }

    }

}

冒泡排序

package com.flyoung;

public class TestBubble {

    public static void bubbleSort(int[] array){
        int i,j;
        boolean flag = true;
        int len = array.length-1;
        for(i=1;i<len&&flag;i++){
            flag = false;
            for(j=len-1;j>=i;j--){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    flag=true;
                }
            }
        }
    }
    public static void swap(int[] array,int i,int j){
        array[0]=array[i];
        array[i]=array[j];
        array[j]=array[0];
    }
    public static void main(String[] args) {
        int[] a = {0,9,1,5,8,3,7,4,6,2};
        bubbleSort(a);
        for(int i=1;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }

    }

}

快速排序

package com.flyoung;

public class TestQuick {
    public static void quickSort(int[] array){
        qSort(array,1,array.length-1);
    }
    public static void qSort(int[] array,int low,int high){
        int privot ;
        if(low<high){
            privot=partition(array,low,high);
            qSort(array,low,privot-1);
            qSort(array,privot+1,high);
        }
        
    }
    public static int partition(int[] array,int low,int high){
        int m = low+(high-low)/2;
        if(array[low]>array[high]){
            swap(array,low,high);
        }
        if(array[m]>array[high]){
            swap(array,m,high);
        }
        if(array[m]>array[low]){
            swap(array,m,low);
        }
        int privotKey = array[low];
        array[0]=privotKey;
        while(low<high){
            while(low<high&&array[high]>privotKey){
                high--;
            }
            array[low]=array[high];
            while(low<high&&array[low]<privotKey){
                low++;
            }
            array[high]=array[low];
        }
        array[low]=array[0];
        return low;
    }
    public static void swap(int[] array,int i,int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }
    public static void main(String[] args) {
        int[] a = {0,56,78,12,45,90,88,59,100,23};
        quickSort(a);
        for(int i=1;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }
    }

}

归并排序

package com.flyoung;

public class TestMerge {
public static void merge(int[] array,int start1,int end1,int start2,int end2){
    int i=start1,j=start2;
    int[] temp = new int[end2-start1+1];
    int k=0;
    while(i<=end1&&j<=end2){
        temp[k++]=array[i]<=array[j]?array[i++]:array[j++];
    }
    while(i<=end1){
        temp[k++]=array[i++];
    }
    while(j<=end2){
        temp[k++]=array[j++];
    }
    k=start1;//关键处，不然每次都会从下标0处开始
    for(int element:temp){
        array[k++]=element;
    }
    
}
public static void mergeSort(int[] array,int s,int t){
    if(s<t){
          int m = (s+t)/2;
            mergeSort(array,s,m);
            mergeSort(array,m+1,t);
            merge(array,s,m,m+1,t);
    }
}
    public static void main(String[] args) {
        int[] a={50,10,60,40,80,90,100,20,30,50};
        mergeSort(a,0,a.length-1);
        for(int i=0;i<a.length;i++){
            System.out.println("a["+i+"]:"+a[i]);
        }
    }

}