排序算法合集（Java）

整理了一下常用的排序算法，算法过程和示意图不详细讲，百度很多，只列代码，如有错误，还望大家指出。

1.冒泡排序

public static void bubbleSort(int[] a){
    for(int i=a.length-1;i>0;i--){
        for(int j=0;j<i;j++){
            if(a[j]>a[j+1]){
                int tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
            }
        }
    }
}

，冒泡排序的时间复杂度为O(n^2)，是稳定的算法

2.快速排序

public static void quickSort(int[] a,int l,int r){
    if(l<r){
        int i,j,x;
        i=l;
        j=r;
        x=a[i];
        while(i<j){
            while(i<j&&a[j]>x)
                j--;
            if(i<j)
                a[i++]=a[j];
            while(i<j&&a[i]<x)
                i++;
            if(i<j)
                a[j--]=a[i];
        }
        a[i]=x;
        quickSort(a,l,i-1);
        quickSort(a,i+1,r);
    }
}

快速排序的时间复杂度O(N*logN),不稳定算法

3.插入排序

public static void insertSort(int[] a){
    int i,j,k;
    for(i=1;i<a,length;i++){
        for(j=i-1;j>=0;j--){
            if(a[j]<a[i])
                break;
        }
        if(j!=i-1){
            int tmp=a[i];
            for(k=i-1;k>j;k--)
                a[k+1]=a[k];
            a[k+1]=tmp;
        }
    }
}

插入排序的时间复杂度O(N^2),稳定的算法

4.希尔排序

public static void shellSort(int[] a){
    for(int gap=a.length/2;gap>0;gap/=2){
        for(int i=0;i<gap;i++){
            for(int j=i+gap;j<a.length;j+=gap){
                if(a[j]<a[j-gap]){
                    int tmp=a[j];
                    int k=j-gap;
                    while(k>=0&&a[k]>tmp){
                        a[k+gap]=a[k];
                        k-=gap;
                    }
                    a[k+gap]=tmp;
                }
            }
        }
    }
}

希尔排序的时间复杂度与gap有关，当增量为1时，蜕化成插入排序，此时的复杂度为O(N^2)，而Hibbard增量的希尔排序的时间复杂度为O(N^3/2)，不稳定算法

5.选择排序

public static void selectSort(int[] a){
    int i,j,min;
    for(i=0;i<a.length;i++){
        min=i;
        for(j=i+1;j<a.length;j++){
            if(a[j]<a[min])
                min=j;
        }
        if(min!=i){
            int tmp=a[i];
            a[i]=a[min];
            a[min]=tmp;
        }
    }
}

选择排序的时间复杂度为O(N^2),稳定的算法

6.堆排序

//最大堆的向下调整算法
publi static void maxHeapDown(int[] a,int start,int end){
    int c=start;
    int l=2*c+1;
    int tmp=a[c];
    for(;l<=end;c=l,l=2*l+1){
        if(l<end&&a[l]<a[l+1])
            l++;
        if(tmp>a[l])
            break;
            else{
                a[c]=a[l];
                a[l]=tmp;
            }
    }
}
//堆排从小到大
public static void heapSortAsc(int[] a,int n){
    int i,tmp;
    for(i=n/2-1;i>=0;i--)
        maxHeapDown(a,i,n-1);
    for(i=n-1;i>0;i--){
        tmp=a[0];
        a[0]=a[i];
        a[i]=tmp;
        maxHeapDown(a,0,i-1);
    }
}

//最小堆的向下调整算法
public static void minHeapDown(int[] a,int start,int end){
    int c=start;
    int l=2*c+1;
    int tmp=a[c];
    for(;i<=end;c=1,l=2*l+1){
        if(l<end&&a[l]<a[l+1])
            l++;
        if(tmp<=a[l])
            break;
        else{
            a[c]=a[l];
            a[l]=tmp;
        }
    }
}

//堆排序从大到小

public static void heapSortDesc(int[] a,int n){
    int i,tmp;
    for(i=n/2-1;i>=0;i--)
        minHeapDown(a,0,n-1);
    for(i=n-1;i>0;i--){
        tmp=a[0];
        a[0]=a[i];
        a[i]=tmp;
        minHeapDown(a,0,i-1);
    }
}

堆排序的时间复杂度O(N*logN)，不稳定算法

7.归并排序

public static void merge(int[] a,int start,int mid,int end){
    int[] tm=new int[end-start+1];
    int i=start;
    int j=mid+1;
    int k=0;
    while(i<=mid&&j<=end){
        if(a[i]<a[j])
            tmp[k++]=a[i++];
        elss
            tmp[k++]=a[j++];
    }
    while(i<=mid)
        tmp[k++]=a[i++];
    while(j<=end)
        tmp[k++]=a[j++];
    for(i=0;i<k;i++)
        a[start+i]=tmp[i]'
    tmp=null;
}
//归并排序（由上往下）

public static void mergeSortUp2Down(int[] a,int start,int end){
    if(a==null||start>=end)
        return;
    int mid=start+(end-start)/2;
    mergeSortUp2Down(a,start,mid);
    mergeSortUp2Down(a,min+1,end);
    merge(a,start,mid,end);
}

//归并排序（从下往上）
public atatic void mergeDown2Up(int[] a){
    if(a==null)
        return;
    for(int n=1;n<a.length;n*=2)
        mergeGroup(a,a.length,n);
}

public static void mergeGroups(int[] a,int len,int gap){
    int i;
    int twolen=2*gap;
    for(i=0;i+2*gap-1<len;i+=(2*gap))
        merge(a,i,i+gap-1,i+2*gap-1);
    if(i+gap-1<len-1)
        merge(a,i,i+gap-1,len-1);
}

归并排序的时间复杂度为O(N*logN)，稳定的算法

8.桶排序

public static void bucketSort(int[] a,int max){
    int[] buckets;
    if(a==null||max<1)
        return;
    buckets=new int[max];
    for(int i=0;i<a.length;i++){
        buckets[a[i]]++;
    }
    for(int i=0,j=0;i<max;i++){
        while((buckets[i]--)>0){
            a[j++]=i;
        }
    }
    buckets=null;
}

转自：http://wangkuiwu.github.io

感谢wangkuiwu大神