快速排序算法

快速排序算法

1.基本思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列百度百科。

2.总体流程

以下列数据示例

50	14	25	36	81	61	74	47	94	74	19

1. 选择数组中的某个数字作为基准值（这里选择第一个元素50）。
2. 小于基准值的数组元素放到数组左边，左边小于基准值的元素不一定有序
3. 大于基准值的数组元素放到数组右边，右边大于基准值的元素也不一定有序
4. 等于基准值的元素，放到数组中间
5. 上述过程称为“分区”。对于左边小于基准值的所有元素递归执行上述1-4步骤。再对于右边大于基准值的所有元素递归执行上述1-4步骤。直到数组有序

上述数组执行过程，每次的基准元素以特殊标记(已排好序的不标记了，容易混淆)

50 25 14 19 81 61 74 47 94 74 36

36 25 14 19 47 50 74 81 94 74 61

19 25 14 36 47 50 74 81 94 74 61

14 19 25 36 47 50 74 81 94 74 61

14 19 25 36 47 50 61 74 94 74 81

14 19 25 36 47 50 61 74 81 74 94

14 19 25 36 47 50 61 74 74 81 94

14 19 25 36 47 50 61 74 74 81 94

3.程序实现(java)

  private static int partition(Comparable[] arr, int l, int r){
      Comparable v = arr[l];  //选择第一个元素作为基准值
      
      int j = l;
      for( int i = l + 1 ; i <= r ; i ++ ) {
          if (arr[i].compareTo(v) < 0) {
              j++;
              swap(arr, j, i);
          }
      }
      swap(arr, l, j);
      //printArray(arr);

      return j;
  }

  // 递归使用快速排序,对arr[l...r]的范围进行排序
  private static void sort(Comparable[] arr, int l, int r){
      if( l >= r )
          return;
      
      int p = partition(arr, l, r);
      sort(arr, l, p-1 );
      sort(arr, p+1, r);
  }

  public static void sort(Comparable[] arr){
      int n = arr.length;
      sort(arr, 0, n-1);
  }

  /**
  * 交换数组arr[] 中下标i和j的元素的值
  */
  private static void swap(Object[] arr, int i, int j) {
      Object t = arr[i];
      arr[i] = arr[j];
      arr[j] = t;
  }

  public static void printArray(Object[] arr) {

      for (int i = 0; i < arr.length; i++){
          System.out.print( arr[i] );
          System.out.print( ' ' );
      }
      System.out.println();
  }

  public static void main(String[] args) {
      // 快速排序是一个O(nlogn)复杂度的算法
      // 可以在1秒之内轻松处理100万数量级的数据
      Integer[] arr = {50,25,14,19,81,61,74,47,94,74,36};
      sort(arr);
      printArray(arr);
  }

4.复杂度

• 时间复杂度：O(nlogn)
• 空间复杂度：快速排序使用递归，递归使用栈，因此它的空间复杂度为O(logn)
• 稳定性：快速排序无法保证相等的元素的相对位置不变，因此它是不稳定的排序算法