Java实现的快速排序算法

import java.util.Arrays;
 import java.util.Random;
  
 public class QuickSort {
     public static final Random RND = new Random();
  
     private static void swap(Object[] array,int i,int j) {
         Object tmp = array[i];
         array[i] = array[j];
         array[j] = tmp;
     }
  
     private static <E extends Comparable<? super E>> int partition(E[] array,int begin,int end) {
         int index = begin + RND.nextInt(end - begin + 1);
         E pivot = array[index];
         swap(array,index,end);
         for (int i = index = begin; i < end; ++i) {
             if (array[i].compareTo(pivot) <= 0) {
                 swap(array,index++,i);
             }
         }
         swap(array,end);
         return (index);
     }
  
     private static <E extends Comparable<? super E>> void qsort(E[] array,int end) {
         if (end > begin) {
             int index = partition(array,begin,end);
             qsort(array,index - 1);
             qsort(array,index + 1,end);
         }
     }
  
     public static <E extends Comparable<? super E>> void sort(E[] array) {
         qsort(array,array.length - 1);
     }
  
     // Example uses
     public static void main(String[] args) {
         Integer[] l1 = { 5,1024,1,88,1024 };
         System.out.println("l1  start:" + Arrays.toString(l1));
         QuickSort.sort(l1);
         System.out.println("l1 sorted:" + Arrays.toString(l1));
  
         String[] l2 = { "gamma","beta","alpha","zoolander" };
         System.out.println("l2  start:" + Arrays.toString(l2));
         QuickSort.sort(l2);
         System.out.println("l2 sorted:" + Arrays.toString(l2));
     }
 }
 
Analogously to the Erlang solution above,a user-supplied {{Javadoc:SE|java/util|Comparator}} determines the partial ordering of array elements:
 
 import java.util.Comparator;
 import java.util.Random;
  
 public class Quicksort {
     public static final Random RND = new Random();
     private static void swap(Object[] array,int j) {
         Object tmp = array[i];
         array[i] = array[j];
         array[j] = tmp;
     }
     private static <E> int partition(E[] array,int end,Comparator<? super E> cmp) {
         int index = begin + RND.nextInt(end - begin + 1);
         Object pivot = array[index];
         swap(array,end);  
         for (int i = index = begin; i < end; ++ i) {
             if (cmp.compare(array[i],pivot) <= 0) {
                 swap(array,end);  
         return (index);
     }
     private static <E> void qsort(E[] array,Comparator<? super E> cmp) {
         if (end > begin) {
             int index = partition(array,end,cmp);
             qsort(array,index - 1,cmp);
         }
     }
     public static <E> void sort(E[] array,Comparator<? super E> cmp) {
         qsort(array,array.length - 1,cmp);
     }
 }