演算法、排序（1）

已知數組int[] max={6,5,2,9,7,4,0};用快速排序演算法按降序對其進行排列，並返回數組

 

public class TestQuickSort {

private int[] array = null;

private void quickSort(int lowest, int highest) {
if (array == null || lowest < 0 || lowest >= highest
|| highest >= array.length) {
return;
}
int low = lowest;
int high = highest;
int key = low++;
for (; low <= high;) {
if (key < high) {
if (array[key] > array[high]) {
array[high] = array[key] + (array[key] = array[high]) * 0;
key = high;
}
high--;
}

if (key > low) {
if (array[key] < array[low]) {
array[low] = array[key] + (array[key] = array[low]) * 0;
key = low;
}
low++;
}
}
quickSort(lowest, key - 1);
quickSort(key + 1, highest);
}

/**
* @param args
*/
public static void main(String[] args) {
TestQuickSort test = new TestQuickSort();
int[] array = {6,5,2,9,7,4,0};
6 5 2 9 7 4 0
0 5 2 9 7 4 6
0 5 2 6 7 4 9
0 5 2 4 7 6 9
0 5 2 4 6 7 9

test.array = array;
test.quickSort(0, array.length - 1);
int length = test.array.length;
for (int i = 0; i < length; i++) {
System.out.println(test.array[i]);
}
}
}
快速排序是綜合效能最好的內部排序演算法！
一 冒泡排序
[演算法描述]
給出N個數，
用第1個與第2個比較，如果N[1]>N[2],則讓N[1]與N[2]交換；
用第2個與第3個比較，如果N[2]>N[3],則讓N[2]與N[3]交換；
………………
用第N-1個與第N個比較，如果N[N-1]>N[N],則讓N[N-1]與N[N]交換；
這樣比較一圈後，最大的數就到最後，接著對剩下的N-1個數進行上述的處理，
把這N-1個數中最大的數放到第N-1的位置上,
到最後就排序OK了.由於過程象氣泡冒出來，就叫冒泡演算法。

[來源程式1]順序冒泡
protected static void MaoPaoSort1(int[] arr){
  for(int i=1;i<arr.Length;i++){        //從1到N迴圈
    for(int j=0;j<arr.Length-i;j++){    //從0到N-i迴圈
      if(arr[j] > arr[j+1]){
        int tmp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = tmp;
      }
    }
  }
}//end MaoPaoSort1 func
 
[來源程式2]逆序冒泡，先比較第N-1個與第N個
protected static void MaoPaoSort2(int[] arr){
  for(int i=0;i<arr.Length-1;i++){
    for(int j=arr.Length-1;j>i;j--){
      if(arr[j-1] > arr[j]){
        int tmp = arr[j-1];
        arr[j-1] = arr[j];
        arr[j] = tmp;
      }
    }
  }
}//end MaoPaoSort2 func
註：上述程式在迴圈中如果加入一個標誌，如果本次迴圈中沒有發生交換，就退出函數，可以提高一些效率

二 選擇排序
[演算法描述]
掃描所有資料,選擇最小的資料與第1個資料互換;
掃描除第1個以外的所有資料,選擇最小的資料與第2個資料互換;
………………
掃描除第N-2個以外的所有資料,選擇最小的資料與第N-1個資料互換;
排序完成，進行N-1次掃描

[來源程式]
protected static void SelectSort(int[] arr){
  for(int i=0;i<arr.Length-1;i++){
    int smallNo = i;
    for(int j=i+1;j<arr.Length;j++){
      if(arr[j] < arr[smallNo]){
        smallNo = j;   //選出最小數的序號
      }
    }
    if(smallNo != i){  //最小數的序號發生了變化就交換
      int tmp = arr[i];
      arr[i] = arr[smallNo];
      arr[smallNo] = tmp;
    }
  }
}//end SelectSort func

三 插入排序
[演算法描述]
首先把數組第一個元素看到排序好的數組，
把第二個元素插入到排序好的數組中，
再把第三個元素插入到前兩個排序好的數組中，如此類推
往一個有序數組中插入一個元素X，使數組依然有序
1.從左至右掃描數組,從第1個大於元素X的數組元素K開始,
  其後的元素依次右移一位，並把X儲存於K的位置；
2.如果大於元素X的數組元素不存在，則在數組末尾插入X

[來源程式]
protected static void InsertSort(int[] arr){
  int ins,i=0,j=0;
  for(i=1;i<arr.Length;i++){
 ins = arr[i];  //等待插入的元素
 if(ins < arr[i-1]){ //i之前（不包括i）的元素是已經排序好的
   j = i-1;
   while( j>=0 && ins < arr[j]){//這裡需要注意一下：不能寫成 ins < arr[j] &&j>=0
  arr[j+1] = arr[j]; //把大於ins的元素依次後移
  j--;    //後移直到讓出ins的位置為止
   }
   arr[j+1] = ins;
 }
  }//end for i
}//end InsertSort func

四 快速排序
[演算法描述]
快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一不部分的所有資料都要小，然後再按次方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。
1.以數組的中間元素為參考值;
2.將中間元素左邊大於參考值的與中間元素右邊小於參考值的元素互換位置;
3.把中間元素左邊的所有元素看成數組，遞迴執行1~4的操作;
4.對中間元素右邊的所有元素看成數組，遞迴執行1~4的操作;

[來源程式]
protected static void QuickSort(int[] arr,int leftNo, int rightNo){
  int mid = (int)Math.Floor((leftNo + rightNo) / 2);//取得中間點
  //Math.Floor(3.6)=3;Math.Ceiling(3.1)=4，用這兩種方法都可以
  int i = leftNo;
  int j = rightNo;
  do{
    while(arr[i] < arr[mid])i++;
    while(arr[j] > arr[mid])j--;
    if(i <= j){
      int tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
      i++;
      j--;
    }
  }while(i<=j);
  if(leftNo < j) QuickSort(arr,leftNo,j);
  if(rightNo > i)QuickSort(arr,i,rightNo);
}//end QuickSort func