import java.util.Arrays;


public class SortTest {


public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = {13,25,61,34,6,74,2,12,1,36,7,3};
for(int num:a)
System.out.print(num+" ");
System.out.println();
/**
* 冒泡測試
*/
int[] bubbleSortArr = bubbleSort(Arrays.copyOf(a, a.length));
for(int num:bubbleSortArr)
System.out.print(num+" ");
System.out.println();
/**
* 選排測試
*/
int[] selectionSortArr = selectionSort(Arrays.copyOf(a, a.length));
for(int num:selectionSortArr)
System.out.print(num+" ");
System.out.println();
/**
* 插排測試
*/
int[] insertSortArr = insertionSort(Arrays.copyOf(a, a.length));
for(int num:insertSortArr)
System.out.print(num+" ");
System.out.println();
/**
* 希爾測試：略
* 歸併測試：略
*/

/**
* 快排測試：
*/
int[] quickSortArr = Arrays.copyOf(a, a.length);
quickSort(quickSortArr, 0, quickSortArr.length-1);
for(int num:quickSortArr)
System.out.print(num+" ");
System.out.println();

}

/**
* 氣泡排序：
* 1比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
   2對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
    3針對所有的元素重複以上的步驟，除了最後一個；
        重複步驟1~3，直到排序完成。
* @param arr
*/
public static int[] bubbleSort(int[] arr){
for(int i=0;i<arr.length;i++){//i只是趟數，不參與比較
for(int j=0;j<arr.length-1-i;j++){//比較j和j+1 所以要-1
if(arr[j]>arr[j+1]){
int temp = arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
/**
* 選擇排序：
* n個記錄的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。具體演算法描述如下：


1.初始狀態：無序區為R[1..n]，有序區為空；
2.第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別為R[1..i-1]和R(i..n）。
     該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，
     使R[1..i]和R[i+1..n)分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；
3.n-1趟結束，陣列有序化了。
* @param arr
*/
public static int[] selectionSort(int[] arr){
int minNumIndex;//儲存最小值索引
for(int i=0;i<arr.length-1;i++){
minNumIndex = i;//首先讓有序區第最末一個作為最小值索引
for(int j=i+1;j<arr.length;j++){
if(arr[j]<arr[minNumIndex]){//尋找最小的數
minNumIndex = j;//將最小數的索引儲存
}
}
int temp = arr[i];
arr[i] = arr[minNumIndex];//交換最小值到有序列末尾
arr[minNumIndex]=temp;
}
return arr;
}

/** 
* 插入排序：
*  1從第一個元素開始，該元素可以認為已經被排序；
2取出下一個元素，在已經排序的元素序列中從後向前掃描；
3如果該元素（已排序）大於新元素，將該元素移到下一位置；
4重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
5將新元素插入到該位置後；
6重複步驟2~5。
* @param arr
* @return
*/
public static int[] insertionSort(int[] arr){
int preIndex,current;
for(int i=1;i<arr.length;i++){//假設第一個有序，向後尋找到最末尾
preIndex = i-1;//儲存已有序的序列最末尾的位置
current=arr[i];
while(preIndex>=0&&arr[preIndex]>current){
arr[preIndex+1] = arr[preIndex];
preIndex--;
}
arr[preIndex+1] = current;
}
return arr;
}
/**
* 希爾排序：
* 先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，具體演算法描述：


1選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2按增量序列個數k，對序列進行k 趟排序；
3每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。
   僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。
*/

/**
* 歸併排序：
* 把長度為n的輸入序列分成兩個長度為n/2的子序列；
對這兩個子序列分別採用歸併排序；
將兩個排序好的子序列合併成一個最終的排序序列。
*/

/**
* 快速排序
* 
* 
* 

*/

public static void quickSort(int[] a, int left, int right){  
        
        int i,j,jizhunshu;   
          
        if(left>right)//左指標必須小於右指標   
        return;   
                                      
        jizhunshu=a[left]; //jizhunshu中存的就是基準數   
        i=left;  //左哨兵  
        j=right; //右哨兵  
          
        while(i!=j){   
        //順序很重要，要先從右邊開始找   
        while(a[j]>=jizhunshu && i<j)//從右向左找小於基準數的值   
        j--;   
            //再找左邊
            while(a[i]<=jizhunshu && i<j)//從左向右找大於基準數的值
            i++;   
            //交換兩個數在陣列中的位置   
            if(i<j){   
                int t=a[i];   
                a[i]=a[j];   
                a[j]=t;   
            }   
        }   
        //最終將基準數歸位   
        a[left]=a[i];   
        a[i]=jizhunshu;   //此時left和right值不變
                                   
        quickSort(a,left,i-1);//繼續處理左邊的，這裡是一個遞迴的過程   
        quickSort(a,i+1,right);//繼續處理右邊的 ，這裡是一個遞迴的過程      
    }  
/**
* 堆排序：
* 建立大/小頂堆，自下而上找順序，不符合交換，然後逐層上翻
*/
}