快排

最近复习快排，快排分为两种实现：双边循环发、单边循环发。
目前使用的是双边循环法，先看下实现代码：

public class my_QuickSort_1 {

  /**
   * 采用随机选取枢纽元素策略的一次快排后的划分索引
   * @param a 待排序数组
   * @param p 区间左端
   * @param r 区间右端
   * @return 采用随机选取枢纽元素策略的一次快排后的划分索引
   */
  @SuppressWarnings("rawtypes")
  private static int randomizedPartition(int[] a,int p,int r){
    return partition(a,p,r);
  }

  /**
   * 采用随机选取枢纽元素策略的快速排序
   * @param a 待排序数组
   * @param p 指定区间的左端
   * @param r 指定区间的右端
   */
  @SuppressWarnings({ "unused", "rawtypes" })
  public static   void randomizedQuickSort(int[] a,int p,int r){
    if(p<r){
      int q=randomizedPartition(a,p,r);
      randomizedQuickSort(a,p,q-1);
      randomizedQuickSort(a,q+1,r);
    }
  }

  /**
   * 求划分索引
   * @param a 待排序数组
   * @param p 区间左端
   * @param r 区间右端
   * @return 划分索引
   */
  @SuppressWarnings({ "rawtypes", "unchecked" })
  private static int partition(int[] a,int p,int r){
    int i=p,j=r+1;
    int x=a[p];
    while(true){
      while(a[++i] < x&&i<r);
      while(a[--j]> x);
      if(i>=j)break;
      swap(a,i,j);
    }
    a[p]=a[j];
    a[j]=x;
    return j;
  }

  /**
   *
   * @param a
   * @param i
   * @param j
   */
  @SuppressWarnings("rawtypes")
  private  static void swap(int[] a,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
  }
  public static void main(String[] args){
    int[] ints = {1, 67, 3, 26, 2, 6, 2, 6, 2, 8, 2, 8};
    randomizedQuickSort(ints,0,11);
    System.out.println(Arrays.toString(ints));
  }
}

单边循环法：

public class xiaohui_QuickSort2 {

  public static void quickSort(int[] arr, int startIndex, int endIndex) {
    // 递归结束条件：startIndex大等于endIndex的时候
    if (startIndex >= endIndex) {
      return;
    }
    // 得到基准元素位置
    int pivotIndex = partition(arr, startIndex, endIndex);
    // 根据基准元素，分成两部分递归排序
    quickSort(arr, startIndex, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, endIndex);
  }

  /**
   * 分治（单边循环法）
   * @param arr     待交换的数组
   * @param startIndex    起始下标
   * @param endIndex    结束下标
   */
  private static int partition(int[] arr, int startIndex, int endIndex) {
    // 取第一个位置的元素作为基准元素（也可以选择随机位置）
    int pivot = arr[startIndex];
    int mark = startIndex;

    for(int i=startIndex+1; i<=endIndex; i++){
      if(arr[i]<pivot){
        mark ++;
        int p = arr[mark];
        arr[mark] = arr[i];
        arr[i] = p;
      }
    }

    arr[startIndex] = arr[mark];
    arr[mark] = pivot;
    return mark;
  }

  public static void main(String[] args) {
    int[] arr = new int[] {4,4,6,5,3,2,8,1};
    quickSort(arr, 0, arr.length-1);
    System.out.println(Arrays.toString(arr));
  }
}