八种基本排序算法

选择排序：

private static void selectSort(int a[],int n){
        for(int i=0;i<n;i++){
            int tmp=a[i];
            int flag=i;
            for(int j=i+1;j<n;j++){
                if(a[j]<tmp){
                    tmp=a[j];
                    flag=j;
                }
            }
            if(flag!=i){
                a[flag]=a[i];
                a[i]=tmp;
            }
        }
    }

插入排序(稳定排序)：

    private static void insertSort(int a[],int n){
        if(a!=null && n!=0){
            for(int i=1;i<n;i++){
                if(a[i-1]>a[i]){
                    int tmp=a[i];
                    int j=i;
                    while(j>0&&a[j-1]>tmp){
                        a[j]=a[j-1];
                    }
                    a[j]=tmp;
                }
            }
        }
    }

希尔排序：

    private static void shellSort(int a[],int n){
        for(int h=n/2;h>0;h/=2){
            for(int i=h;i<n;i++){
                if(a[i]<a[i-h]){
                    int tmp=a[i];
                    int flag=i;
                    while(flag-h>=0&&a[flag-h]>tmp){
                        a[flag]=a[flag-h];
                        flag-=h;
                    }
                    a[flag]=tmp;
                }
            }
        }
    }

冒泡排序(稳定排序)：

        private static void bubbleSort(int a[],int n){
        for(int i=n-1;i>0;i--){
            boolean flag=true;;
            for(int j=0;j<n-1;j++){
                if(a[j]>a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=false;
                }
            }
            if(flag){
                return;
            }
        }
    }

堆排序：

    private static void heapSort(int a[],int n){
        for(int i=n/2-1;i>=0;i--){
            adjustHeap(a,i,n);
        }
        for(int i=n-1;i>=0;i--){
            int tmp=a[0];
            a[0]=a[i];
            a[i]=tmp;
            adjustHeap(a,0,i);
        }
    }

    private static void adjustHeap(int []a,int pos,int len){
        int tmp = a[pos];
        while(2 * pos + 1 < len) {
            int child=2*pos+1;
            if(child+1<len&&a[child]<a[child+1]){
                child++;
            }
            if(a[child]>tmp){
                a[pos]=a[child];
            }else{
                break;
            }
            pos = child;
        }
        a[pos]=tmp; 
    }

归并排序(稳定排序):

private static void mergeSort(int a[],int l,int r){
        if(l<r){
            int mid=(l+r)/2;
            mergeSort(a,l,mid);
            mergeSort(a,mid+1,r);
            merge(a,l,r);
        }
    }
    private static void merge(int a[],int l,int r){
        int mid=(l+r)/2;
        int i,j,k;
        int len1=mid-l+1;
        int len2=r-mid;
        int L[]=new int[len1];
        int R[]=new int[len2];
        for(i=0,k=l;i<len1;i++,k++){
            L[i]=a[k];
        }
        for(i=0,k=mid+1;i<len2;i++,k++){
            R[i]=a[k];
        }
        for(k=l,i=0,j=0;i<len1&&j<len2;k++){
            if(L[i]<R[j]){
                a[k]=L[i];
                i++;
            }else{
                a[k]=R[j];
                j++;
            }
        }
        if(i<len1){
            while(i<len1){
                a[k++]=L[i++];
            }
        }
        if(j<len2){
            while(j<len2){
                a[k++]=R[j++];
            }
        }
    }

快速排序：

private static void quickSort(int a[],int l,int r){
        if(l<r){
            int i=l,j=r,index=a[l];//i为前指针,j为后指针,index为基准值
            //因为每次操作都要移动指针,因此每次都要判断指针是否交错
            while(i<j){
                //先把比基准值大的移到左边
                while(i<j&&a[j]>=index){
                    j--;
                }
                if(i<j){
                    a[i]=a[j];
                }
                //再把比基准值大的移到右边
                while(i<j&&a[i]<index){
                    i++;
                }
                if(i<j){
                    a[j]=a[i];
                }
            }
            //最终i=j,比index大的都在i右边,比index小的都在i左边
            a[i]=index;
            quickSort(a,l,i-1);
            quickSort(a,i+1,r);
        }
    }

基数排序(稳定排序)：

public static void radixSort(int[] a, int len, int maxBit) {
        int n = 1; //用来辅助计算a[i]的bitNum位的数
        int bitNum = 1; //从低位往高位排，排到第几位
        int[][]temp = new int[10][len]; //表示bitNum为i的第j+1个数
        int[]order = new int[10]; //表示bitNum位是i的数的个数
        while(bitNum++ <= maxBit){
            for(int i = 0; i < len; i++) {
                int rem = ((a[i] / n) % 10);//a[i]的bitNum位的数
                temp[rem][order[rem]] = a[i];
                order[rem]++;
            }
            int k = 0;
            for(int i = 0; i < 10; i++) {//O(n)的复杂度
                if(order[i] != 0) {
                    for(int j = 0; j < order[i]; j++) {
                        a[k] = temp[i][j];
                        k++;
                    }
                }
                order[i] = 0;
            }
            n *= 10;
        }
    }