【四大排序的总结】

八大排序：的时间复杂度。

这里只写下四大排序的内容

插入排序：

/**
 * 插入排序
 * @author Jay-Tang
 *
 */
public class insertsort {

       static int[] arrayint ={12,23,223,11,22};


       private static void paixu() {
        //外層循環
           for(int i=0;i<arrayint.length-1;i++){
               for(int j=i+1; j>0; j-- ){
                 while(arrayint[i+1]>arrayint[i]){
                     break;
                 }
                   if (arrayint[j-1]>arrayint[j]) {
                       //交換位置
                      int tmp=arrayint[j-1];
                     arrayint[j-1]=arrayint[j];
                     arrayint[j]=tmp;
                   }
               }
           }
       } 
      //輸出排序的函數
      public static void main(String[] args) {
        paixu();
       for(int i=0;i<arrayint.length;i++){
        System.out.println(arrayint[i]);
        }
    }


}

快速排序：

public class kuaisupaixu {
    //一個數組
    static int [] intarray={12,232,23,232,32,32};
    //判斷是否為空
    public static boolean  isEmpty(int[] n){
        return n==null||n.length==0;    
    }
    public static void quicksort(int [] n){
        if (isEmpty(n)) {
            return;
        }
        quicksort(n,0,n.length-1);

    }
    private static void quicksort(int[] n, int l, int h) {
        if (isEmpty(n)) {
            return;
        }
        if (l<h) {
            //基质pivot
            int pivot=partion(n,l,h);
            //正向比一次
            quicksort(n,l,pivot-1);
            //反向比一次
            quicksort(n,pivot+1,h);
        }

    }
    //排出基质
    private static int partion(int[] n, int start, int end) {
    //以起始点位基质
        int tmp=n[start];
    //当初始值小于end
        while(start<end){
        //当最后一位数大于基数  不变
            while(n[end]>=tmp&&start<end){
                //最后一位的指针前移一位
                end--;  }
               //否则交换位置
                if (start<end) {
                    n[start++]=n[end];
                }
                while(n[start]<tmp&&start<end){
                start++;
                }
                //否则交换位置    
                if (start<end) {
                    n[end]=n[start];
                    end--;
                }
                }

        n[start]=tmp;   
        return start;

    }


    public static void main(String[] args) {
    quicksort(intarray);
    for(int i=0;i<intarray.length;i++){
        System.out.println(intarray[i]);

    }
}


}

冒泡：

/**
 * 從下到大排
 * @author Jay-Tang
 *
 */
public class maopao {
    //数组
    static int [] intarray={12,232,23,232,32,32};

    //
public static void main(String[] args) {

    //排序外層循環
    for(int i=0;i<intarray.length;i++){
    //內存循環  如果比下一個大就替換 注意數組越界的問題   
        for(int j=intarray.length-1;j>0;j--){
            if (intarray[j-1]>intarray[j]) {
                int tmp=intarray[j-1];
                intarray[j-1]=intarray[j];
                intarray[j]=tmp;
            }
        }
}
for(int i=0;i<intarray.length;i++){
    System.out.println(intarray[i]);
}
}
}

选择：

import javax.print.attribute.standard.MediaName;

/**
 * 選擇排序
 * 原理是先選排出最小的再選
 * @author Jay-Tang
 *
 */
public class xuanzepaixu {
     static int[] arrayint ={12,23,223,11,22};

     //外層循環
     public static void paixu(){
         //
         for(int i=0;i<arrayint.length;i++){
             for(int j=i+1;j<arrayint.length;j++){
                 //如果比第n個小
             if (arrayint[i]>arrayint[j]) {
                 int tmp=arrayint[i];
                 arrayint[i]=arrayint[j];
                 arrayint[j]=tmp;
            }
             }
         }


     } 
    //輸出排序的函數
    public static void main(String[] args) {
        paixu();
    for(int i=0;i<arrayint.length;i++){
        System.out.println(arrayint[i]);
    }
    }

}

源码见github：https://github.com/tangsilian/securitystudy/tree/master/Swap