9大排序实现以及各自特点

来源：互联网发布：淘宝管制刀具编辑：程序博客网时间：2024/05/21 18:40

9大排序实现以及各自特点

时间复杂度为O(n^2)

/** * 冒泡排序，时间复杂度O(n^2)，空间复杂度O(1) * 稳定排序 * 原始顺序不影响排序效率，但可以通过设置标记（如果一次冒泡未发生交换，即可判断有序），原始顺序就会影响排序效率 * @author weifucheng * */public class BubbleSort {        public int[] bubbleSort(int[] A,int n){            for(int i=0;i<n;i++){                for(int j=1;j<n-i;j++){                    if(A[j]<A[j-1]){                        int t;                        t=A[j];                        A[j]=A[j-1];                        A[j-1]=t;                    }                }            }            return A;        }}

/** * 选择排序,时间复杂度O(n^2),空间复杂度O(1) * 不稳定排序 * 原始顺序不影响排序效率 * @author weifucheng * */public class SelectionSort {    public int[] selectionSort(int[] A, int n) {            int m=A[0];            int mindex=0;            int t;            for(int i=0;i<n;i++){                for(int j=0;j<n-i;j++){                    if(A[j]>m){                        m=A[j];                        mindex=j;                    }                }                t=A[mindex];                A[mindex]=A[n-i-1];                A[n-i-1]=t;                m=A[0];                mindex=0;            }            return A;    }}

/** * 插入排序，时间复杂度O(n^2),空间复杂度O(1) * 稳定排序 * 原始顺序影响排序效率 * @author weifucheng * */public class InsertionSort {     public int[] insertionSort(int[] A, int n) {            for(int i=0;i<n;i++){                int t=A[i];                int j;                for(j=i;j>0&&A[j-1]>t;j--){                    A[j]=A[j-1];                }                A[j]=t;            }            return A;        }}

时间复杂度为O(n*logn)

/** * 堆排序，时间复杂度O(n*logn),空间复杂度O(1) * 不稳定排序 * 原始顺序影响排序效率 * @author weifucheng * */public class HeapSort {    public int[] heapSort(int[] A, int n) {        for(int i=n/2;i>=0;i--){            heapJust(A,i,n);        }        int t;        for(int i=n-1;i>0;i--){            t=A[i];            A[i]=A[0];            A[0]=t;            heapJust(A,0,i);        }        return A;    }    private void heapJust(int[] A,int index,int length){            int cl;            int temp=A[index];            for(;index*2+1<length;index=cl){                cl=index*2+1;                if(cl!=length-1&&A[cl]<A[cl+1]){                    cl++;                }                if(A[cl]<temp){break;}                else{                    A[index]=A[cl];                    index=cl;                }            }            A[index]=temp;    }}

/** * 快速排序时间复杂度O(n*logn),空间复杂度O(logn)~O(logn) * 不稳定排序 * 原始顺序会影响排序效率 * @author lenovo * */public class QuickSort {    public int[] quickSort(int[] A, int n) {            quick(A,0,n-1);            return A;    }    public void quick(int[] A,int low,int height){        if(low<height){            int middle=sort(A,low,height);            quick(A,low,middle-1);            quick(A,middle+1,height);        }    }    public int sort(int[] A,int low,int height){            int i=low;            int j=height;            int key=A[low];            if(j>i){                while(j>i){                    while(j>i&&A[j]>=key){                        j--;                    }                    if(j>i){                        A[i]=A[j];                    }                    while(j>i&&A[i]<=key){                        i++;                    }                    if(j>i){                        A[j]=A[i];                    }                }                A[i]=key;            }            return i;    }}

/** * 归并排序，时间复杂度O(n*logn),空间复杂度O(n) * 稳定排序 * 原始顺序不会影响排序效率 * @author weifucheng * */public class MergeSort {    public int[] mergeSort(int[] A, int n) {        sort(A,0,n-1);        return A;    }    private void sort(int[] A,int left,int right){        if(left<right){            int middle=(left+right)/2;            sort(A,left,middle);            sort(A,middle+1,right);            merge(A,left,middle,right);        }    }    private void merge(int [] A,int left,int middle,int right){        int leftindex=left;        int rightindex=middle+1;        int golbal=0;        int[] tempArr=new int[right-left+1];        while(leftindex<(middle+1)&&rightindex<(right+1)){            if(A[leftindex]<=A[rightindex]){                tempArr[golbal++]=A[leftindex++];            }else{                tempArr[golbal++]=A[rightindex++];            }        }        while(leftindex<(middle+1)){            tempArr[golbal++]=A[leftindex++];        }        while(rightindex<(right+1)){            tempArr[golbal++]=A[rightindex++];        }        int t=0;        while((t+left)<(right+1)){            A[left+t]=tempArr[t];            t++;        }    }}

/** * 希尔排序，时间复杂度O(n*logn),空间复杂度O(1) * 不稳定排序 * 原始顺序影响排序效率 * @author weifucheng * */public class ShellSort {    public int[] shellSort(int[] A, int n) {        int feet=n/2;        int i,j,t;        while(feet>0){            for(i=feet;i<n;i++){                t=A[i];                for(j=i;j>(feet-1)&&A[j-feet]>t;j=j-feet){                    A[j]=A[j-feet];                }                A[j]=t;            }            feet=feet/2;        }        return A;    }}

时间复杂度为O(n)

/** * 计数排序，时间复杂度O(n),空间复杂度O(m) * 稳定排序 * @author weifucheng * */public class CountingSort {    public int[] countingSort(int[] A, int n) {        int max=A[0];        for(int i=0;i<n;i++){            if(max<A[i]) max=A[i];         }        int min=A[0];        for(int i=0;i<n;i++){            if(min>A[i]) min=A[i];         }        int c=max-min+1;        int[] t=new int[c];        for(int i=0;i<n;i++){            t[A[i]-min]++;        }        int j=0;        for(int i=0;i<c;i++){            while(t[i]>0){                A[j]=min+i;                t[i]--;                j++;            }        }        return A;    }}

/** * 基数排序，时间复杂度为O(n),空间复杂度为O(m) * 稳定排序 * @author weifucheng * */public class RadixSort {    public int[] radixSort(int[] A, int n) {        if(null==A ||n<2) return A;        int[] bucket=new int[n];        int[] count=new int[10];        for(int i=1;i<=4;i++){            for(int j=0;j<10;j++){                count[j]=0;            }            for(int j=0;j<n;j++){               count[getNum(A[j],i)]++;            }            for(int k=1;k<10;k++){                count[k]=count[k]+count[k-1];            }            for(int m=n-1;m>=0;m--){                int num=getNum(A[m],i);                bucket[count[num]-1]=A[m];                count[num]--;            }            for(int c=0;c<n;c++){                A[c]=bucket[c];            }        }        return A;    }    private int getNum(int x,int d){        int[] a={1,1,10,100,1000};        return (x/a[d]%10);    }}

0 0