詳解Java中應用泛型完成疾速排序算法的辦法

詳解Java中應用泛型完成疾速排序算法的辦法。本站提示廣大學習愛好者：（詳解Java中應用泛型完成疾速排序算法的辦法）文章只能為提供參考，不一定能成為您想要的結果。以下是詳解Java中應用泛型完成疾速排序算法的辦法正文

疾速排序算法概念
疾速排序普通基於遞歸完成。其思緒是如許的：
1.選定一個適合的值（幻想情形中值最好，但完成中普通應用數組第一個值）,稱為“樞軸”(pivot)。
2.基於這個值，將數組分為兩部門，較小的分在右邊，較年夜的分在左邊。
3.可以確定，如斯一輪上去，這個樞軸的地位必定在終究地位上。
4.對兩個子數組分離反復上述進程，直到每一個數組只要一個元素。
5.排序完成。

根本完成方法：

public static void quickSort(int[] arr){
  qsort(arr, 0, arr.length-1);
}
private static void qsort(int[] arr, int low, int high){
  if (low < high){
    int pivot=partition(arr, low, high);    //將數組分為兩部門
    qsort(arr, low, pivot-1);          //遞歸排序左子數組
    qsort(arr, pivot+1, high);         //遞歸排序右子數組
  }
}
private static int partition(int[] arr, int low, int high){
  int pivot = arr[low];   //樞軸記載
  while (low<high){
    while (low<high && arr[high]>=pivot) --high;
    arr[low]=arr[high];       //交流比樞軸小的記載到左端
    while (low<high && arr[low]<=pivot) ++low;
    arr[high] = arr[low];      //交流比樞軸小的記載到右端
  }
  //掃描完成，樞軸到位
  arr[low] = pivot;
  //前往的是樞軸的地位
  return low;
}

應用泛型完成快排算法

上面設計一個QuickSort類，包括了靜態函數sort()，可以對隨意率性類型數組停止排序。假如為對象類型數組，則該對象類型必需完成Comparable接口，如許能力應用compareTo函數停止比擬。

應用了最根本的快排算法，沒有停止優化處置。

源代碼以下：

import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;
 
public class QuickSort {
  @SuppressWarnings("unchecked")
  //對上述快排函數原型修正，使其可以對隨意率性對象類型數組停止排序。這個函數為外部應用，內部排序函數接口為sort()，sort函數請求對象必需完成Comparable接口，可以供給編譯時類型檢測，見後文。
  private static void quickSort(Object[] in,int begin, int end) {
    if( begin == end || begin == (end-1) ) return;
    Object p = in[begin];
    int a = begin +1;
    int b = a;
    for( ; b < end; b++) {
      //該對象類型數組必需完成Comparable接口，如許能力應用compareTo函數停止比擬
      if( ((Comparable<Object>)in[b]).compareTo(p) < 0) {
        if(a == b){a++; continue;}
        Object temp = in[a];
        in[a] = in[b];
        in[b] = temp;
        a++;
      }
    }
    in[begin] = in[a-1];
    in[a-1] = p;
    if( a-1 > begin){
      quickSort(in,begin, a);
    } 
    if( end-1 > a ) {
      quickSort(in,a, end);
    } 
    return;
  }
   
  //應用泛型，對隨意率性對象數組排序，該對象類型數組必需完成Comparable接口
  public static <T extends Comparable<? super T>> void sort(T[] input){
    quickSort(input,0,input.length);
  }
   
  //添加對List對象停止排序的功效，參考了Java中的Java.util.Collections類的sort()函數
  public static <T extends Comparable<? super T>> void sort(List<T> list){
    Object[] t = list.toArray();//將列表轉換為數組
    quickSort(t,0,t.length); //對數組停止排序
    //數組排序完成後再寫回到列表中
    ListIterator<T> i = list.listIterator();
    for (int j=0; j<t.length; j++) {
      i.next();
      i.set((T)t[j]);
    }
  }
   
  //因為Java華夏始數據類型（int、double、byte等）沒法應用泛型，所以只能應用函數重載機制完成對這些原始類型數組（int[]、double[]、byte[]等）的排序。這裡為了共用統一個排序函數，應用原始類型的(AutoBoxing，UnBoxing)機制將其封裝為對應對象類型，構成新的對象數組，排序後再解封裝，如許的缺陷是須要額定的轉換步調、額定的空間保留封裝後的數組。另外一種方法是將排序代碼復制到各個重載函數中，官方API中的Java.util.Arrays這個類中的sort()函數就是應用這類辦法，可以從Arrays類的源代碼看出。
  public static void sort(int[] input){
    Integer[] t = new Integer[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];//封裝
    }
    quickSort(t,0,t.length);//排序
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];//解封裝
    }
  }
  //double[]數組的重載函數
  public static void sort(double[] input){
    Double[] t = new Double[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];
    }
    quickSort(t,0,t.length);
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];
    }
  }
  //byte[]數組的重載函數
  public static void sort(byte[] input){
    Byte[] t = new Byte[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];
    }
    quickSort(t,0,t.length);
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];
    }
  }
  //short[]數組的重載函數
  public static void sort(short[] input){
    Short[] t = new Short[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];
    }
    quickSort(t,0,t.length);
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];
    }
  }
  //char[]數組的重載函數
  public static void sort(char[] input){
    Character[] t = new Character[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];
    }
    quickSort(t,0,t.length);
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];
    }
  }
  //float[]數組的重載函數
  public static void sort(float[] input){
    Float[] t = new Float[input.length];
    for(int i = 0; i < input.length; i++){
      t[i] = input[i];
    }
    quickSort(t,0,t.length);
    for(int i = 0; i < input.length; i++){
      input[i] = t[i];
    }
  }
   
  //測試用的main函數
   public static void main(String[] args) {
    //臨盆一個隨機數構成的int[]數組，用來測試
    int LEN = 10;
    int[] input = new int[LEN];
    Random r = new Random();
    System.out.print("int[] before sorting: ");
    for(int i = 0; i < input.length; i++) {
      input[i] = r.nextInt(10*LEN);
      System.out.print(input[i] + " ");
    }
    System.out.println();
    System.out.print("int[] after sorting: ");
    sort(input);
    for(int i : input) {
     System.out.print(i + " ");
    } 
    System.out.println();
 
    //生成一個字符串數組，用來測試
    String[] s = new String[]{"b","a","e","d","f","c"};
    System.out.print("String[] before sorting: ");
    for(int i = 0; i < s.length; i++) {
      System.out.print(s[i] + " ");
    }
    System.out.println();
    System.out.print("String[] after sorting: ");
    sort(s);
    for(int i = 0; i < s.length; i++) {
      System.out.print(s[i] + " ");
    }
    System.out.println();
     
    //生成一個字符串列表，用來測試
    List<String> l = new LinkedList<String>();
    s = new String[]{"b","a","e","d","f","c"};
    System.out.print("LinkedList<String> before sorting: ");
    for (int j=0; j<s.length; j++) {
      l.add(s[j]);
      System.out.print(s[j] + " ");
    }
    System.out.println();
    sort(l);
    System.out.print("LinkedList<String> after sorting: ");
    for (String ts : l) {
      System.out.print(ts + " ");
    }
    System.out.println();
  }
}

運轉main函數測試，從輸入可以看出QuickSort類任務正常：

int[] before sorting: 65 48 92 26 3 8 59 21 16 45
int[] after sorting: 3 8 16 21 26 45 48 59 65 92
String[] before sorting: b a e d f c 
String[] after sorting: a b c d e f 
LinkedList<String> before sorting: b a e d f c 
LinkedList<String> after sorting: a b c d e f