package com.排序;

public class 氣泡排序 {

/*
 *  氣泡排序，就是將第一個記錄的值和第二個記錄的值進行比較
 *  如果，前面的值比後面的值大，則交換位置
 *  反之，則不交換位置
 *  這樣經過這樣的一趟後，最大的值排在了最後面。所以下次迴圈的時候，可以少迴圈一次。 
 * */

private static void maopao(Integer [] a){
    //long starttime = System.currentTimeMillis();
    if(a.length > 0){
        for(int j=0; j<a.length-1; j++){
            for (int i=0; i < a.length-j-1/* a.length=6*/; i++){
                if(a[i] > a[i+1])
                {
                    Integer tmp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = tmp;
                }
            }
        }
    }
    //long endtime = System.currentTimeMillis();
    //System.out.println("冒泡："+(endtime-starttime));
}

/*
 * 快速排序
 * */
private static void QuickSort(Integer[] array,int start,int end) { 
    //long starttime = System.currentTimeMillis();
       if(start<end) { 
           int key=array[start];//初始化儲存基元  
           //初始化i,j 
           int i=start;
           int j;
           for(j=start+1;j<=end;j++) {
             //如果此處元素小於基元，則把此元素和i+1處元素交換，並將i加1，如大於或等於基元則繼續迴圈 
               if(array[j]<key)  { 
                   int temp=array[j]; 
                   array[j]=array[i+1]; 
                   array[i+1]=temp; 
                   i++; 
               } 

           } 
           array[start]=array[i];//交換i處元素和基元  
           array[i]=key; 
           QuickSort(array, start, i-1);//遞迴呼叫  
           QuickSort(array, i+1, end); 

       }
       //long endtime = System.currentTimeMillis();
       //System.out.println("排序："+(endtime-starttime));
}

/*
 * 選擇排序(升序)
 * 首先選擇陣列的首元素a[0]，認為它是最小的
 * 再一一與其他的元素進行比較，第一趟就能得到該陣列的最小值
 * 依次類推
 * 把每一趟獲取的最小值，放在a[n-1]位置上。
 * 這樣就是一個排完序的升序陣列
 * */
public static void xuanzeSort(Integer [] a){

    for(int j=0; j<a.length-1; j++){
        int min = a[j];
        for(int i=j; i<a.length-1; i++){
            if(min > a[i+1]){
                min = a[i+1];

                //交換位置
                int tmp = a[i+1];
                a[i+1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

/*
 * 選擇排序(降序)
 * 首先選擇陣列的首元素a[0]，認為它是最大的
 * 再一一與其他的元素進行比較，第一趟就能得到該陣列的最大值
 * 依次類推
 * 把每一趟獲取的最大值，放在a[n-1]位置上。
 * 這樣就是一個排完序的降序陣列
 * */
public static void xuanzeSortdesc(Integer [] a){

    for(int j=0; j<a.length-1; j++){
        int min = a[j];
        for(int i=j; i<a.length-1; i++){
            if(min < a[i+1]){
                min = a[i+1];

                //交換位置
                int tmp = a[i+1];
                a[i+1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

//測試
public static void main(String[] args) {
    Integer [] a = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};

    //測試冒泡
    maopao(a);
    for(int i=0; i<=a.length-1; i++){
        System.out.print(a[i]+" "); 
    }

    System.out.println("");

    //測試快速排序
    Integer [] b = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    QuickSort(b, 0, b.length-1);
    for(int i=0; i<=b.length-1; i++){
        System.out.print(b[i]+" "); 
    }

    System.out.println("");

    //測試升序選擇排序
    Integer [] c = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    xuanzeSort(c);
    for(int i=0; i<=c.length-1; i++){
        System.out.print(c[i]+" "); 
    }

    System.out.println("");

    //測試降序選擇排序
    Integer [] d = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    xuanzeSortdesc(d);
    for(int i=0; i<=d.length-1; i++){
        System.out.print(d[i]+" "); 
    }
}
 

}