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

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);
    }
}