8大排序算法的java实现

关于八大排序算法，大家肯定都不陌生，相关的概念可以从博主另一边转载的文章中去看看。

http://blog.csdn.net/clx44551/article/details/51240796

这里主要给出8大排序算法的java实现。

1. 冒泡排序

平均复杂度O(n^2)，最好情况O(n)，最差情况O(n^2)。稳定

class Main{
    public static void main(String[] args){
        int[] n=new int[]{113,448,66,2,165,84,13,2,64,153};
        Sort(n);
        System.out.println(Arrays.toString(n));
    }
    public static int[] Sort(int[] arr){
        int length=arr.length;
        for(int i=0;i<length;i++)
            for(int j=0;j+1<length-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        return arr;
    }
}

2. 快速排序

平均复杂度O(nlog2n)，最好情况O(nlog2n)，最差情况O(n^2)。不稳定

class Main {
    public static void main(String[] args) {
        int[] num = new int[] { 21, 5, 13, 2, 45, 6, 3, 7 };
        quickSort(num, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
    }
    public static void quickSort(int[] list, int low, int high) { 
        if (low < high) {  
            int middle = getMid(list, low, high);  //将list数组进行一分为二  
            quickSort(list, low, middle - 1);        //对低字表进行递归排序  
            quickSort(list, middle + 1, high);       //对高字表进行递归排序  
        }  
    }
    public static int getMid(int[] arr,int low,int hight){
        int i=low;
        int j=hight;
        int k=arr[low];
        while(i<j){
            while(i<j&&arr[j]>k)j--;
            if(i<j){
                arr[i]=arr[j];
                arr[j]=k;
                i++;
            }
            while(i<j&&arr[i]<k)i++;
            if(i<j){
                arr[j]=arr[i];
                arr[i]=k;
                j--;
            }       
        }
        return i;
    }
} 

3. 插入排序

简介：插排在数组大部分排序正确的情况下，效率高。依次取数组的前n项进行排序。

平均复杂度O(n^2)，最好情况O(n)，最差情况O(n^2)。稳定

class Main{
    public static void main(String[] args){
        int[] n=new int[]{113,448,66};
        insertSort(n);
        System.out.println(Arrays.toString(n));
    }
    public static int[] insertSort(int[] arr){
        if(arr==null||arr.length<2) return arr;
        for(int i=0;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    int temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }else{break;}
            }
        }
        return arr;
    }

4. 希尔排序

简介：插排在数组大部分排序正确的情况下，效率高。因此有了希尔排序，将一个数组分成d份，分别进行插排。数组长度为length，d一般取值为[length/2,length/4,…….1]，最后为1。

平均复杂度O(n^1.3)，最好情况O(n)，最差情况O(n^2)。不稳定

class Main{
    public static void main(String[] args){
        int[] n=new int[]{113,448,66,2,165,84,13,2,64,153};
        xierSort(n);
        System.out.println(Arrays.toString(n));
    }

    public static int[] xierSort(int[] arr){
        int d=arr.length;       
        while(true){    
            d=d/2;
            for(int j=0;j<d;j++){                 //根据d，将数组分为d组
                for(int i=j+d;i<arr.length;i+=d){ //对每一组分别进行插排
                    for(int k=i-d;k>=0;k=k-d){    //for中为一组里面插排的过程
                        if(arr[k+d]<arr[k]){
                            int temp=arr[k+d];
                            arr[k+d]=arr[k];
                            arr[k]=temp;
                        }else {beak;}
                    }
                }
            }
            if(d==1) break;     
        }
        return arr;
    }
}

5. 选择排序

简介：
第一趟，从数组中找出最小的数与第一个交换；
第二趟，从第二个数开始找到数组中最小的数与第二个交换；
以此类推…..

平均复杂度O(n^2)，最好情况O(n^2)，最差情况O(n^2)。不稳定

class Main{
    public static void main(String[] args){
        int[] n=new int[]{113,448,66,2,165,84,13,2,64,153};
        Sort(n);
        System.out.println(Arrays.toString(n));
    }
    public static int[] Sort(int[] arr){
        int length=arr.length;
        for(int i=0;i<length-1;i++)
            for(int j=i+1;j<length;j++){
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        return arr;
    }
}

- 后面将持续更新别的排序算法….