Java最基礎的五種排序方式

Java五種排序方式

1.隨機數字

隨機生成數字，進行測試

private int [] arrs;
private int count=0;
public Test(int size){
    count=size;
    arrs=new int[count];
    Random ran=new Random();
    for (int i = 0; i < count; i++) {
        //隨機到1000
        arrs[i]=ran.nextInt(1000);
    }
}

2.顯示當前數組次數

    public void display(){
        System.out.println("當前數組次序爲：");
        for(int arr:arrs){
            System.out.print(arr+" ");
        }
        System.out.println();
    }

3.測試方法

    //main方法
    public static void main(String[] args) {
        Test t=new Test(20000);
        long time=System.currentTimeMillis();
        t.popo();//冒泡，這邊替換爲其他方法
        System.out.println((System.currentTimeMillis()-time)/60);
    }

4.算法

1.冒泡排序(2W以下)

  /**
     * 冒泡排序基本概念是：
     * 依次比較相鄰的兩個數，將小數放在前面，大數放在後面。
     * 即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。
     * 然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，
     * 直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，
     * 將最大的數放到了最後。在第二趟：仍從第一對數開始比較
     * （因爲可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），
     * 將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），
     * 第二趟結束，在倒數第二的位置上得到一個新的最大數
     *（其實在整個數列中是第二大的數）。如此下去，重複以上過程，直至最終完成排序。
     */
public void popo(){
        for (int i = 0; i < count-1; i++) {
            for (int j = 0; j < count-1-i; j++) {
                if(arrs[j]>arrs[j+1]){
                    int temp=arrs[j];
                    arrs[j]=arrs[j+1];
                    arrs[j+1]=temp;
                }
            }
        }
    }

2.選擇排序(4W以下)

 
   /** 
     * 選擇排序基本思路：
     * 把第一個元素依次和後面的所有元素進行比較。
     * 第一次結束後，就會有最小值出現在最前面。
     * 依次類推
     */
    public void option(){
        for (int i = 0; i < count-1; i++) {
            int pos=i;
            for (int j = i+1; j <count; j++) {
                if(arrs[pos]>arrs[j]){
                    pos=j;
                }
            }
            int temp=arrs[i];
            arrs[i]=arrs[pos];
            arrs[pos]=temp;
        }
    }

3.插入排序(5W以下)

 
/**
     * 插入排序基本思路：
     * 將n個元素的數列分爲已有序和無序兩個部分，如插入排序過程示例下所示： 　　
     * {{a1}，{a2，a3，a4，…，an}} 　　
     * {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　
     * {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　
     * 每次處理就是將無序數列的第一個元素與有序數列的元素從後往前逐個進行比較，
     * 找出插入位置，將該元素插入到有序數列的合適位置中
     */
    public void insert(){
        for(int i=1;i<count;i++){
            int pos=i;
            int temp=arrs[pos];
            while(pos>0&&arrs[pos-1]>temp){
                arrs[pos]=arrs[pos-1];
                pos--;
            }
            arrs[pos]=temp;
        }
    }

4.快速排序(300W以下)

public void quick(int low,int high){
        int l=low,h=high;
        if(l>h){
            return;
        }
        boolean flag=false;
        while(l<h){
            if(arrs[l]<arrs[h]){
                int temp=arrs[l];
                arrs[l]=arrs[h];
                arrs[h]=temp;
                flag=!flag;
            }
            if(flag){
                l++;
            }else{
                h--;
            }
        }
        l--;h++;
        quick(low,l);
        quick(h,high);
    }

5.快速排序2(1000W以下)

public void quick2(int low,int high){
        if(high-low<=0){
            return ;
        }else{
            int num = arrs[high];
            int pos = partcals(low,high,num);
            quick2(low,pos-1);
            quick2(pos+1,high);
        }
    }
    private int partcals(int low, int high, int num) {
        int leftPtr = low-1;
        int rightPtr = high;
        while(true){
            while(arrs[++leftPtr]<num);
            while(rightPtr>0 && arrs[--rightPtr]>num);
            if(leftPtr >=rightPtr){
                break;
            }else{
                int temp=arrs[leftPtr];
                arrs[leftPtr]=arrs[rightPtr];
                arrs[rightPtr]=temp;
            }
        }
        int temp=arrs[leftPtr];
        arrs[leftPtr]=arrs[high];
        arrs[high]=temp;
        return leftPtr;
    }