快速排序(一)

转载 2006年06月22日 13:47:00

/**
* <p>Title:快速排序 </p>
* <p>Description:
 * 速排序法(quick sort)是目前所公認最快的排序方法之一(視解題的對象而定),
 * 雖然快速排序法在最差狀況下可以達O(n2),但是在多數的情況下,快速排序法的效率表現是相當不錯的。
 * 快速排序法的基本精神是在數列中找出適當的軸心,然後將數列一分為二,分別對左邊與右邊數列進行排序,而影響快速排序法效率的正是軸心的選擇。
 * </p>
* <p>Copyright: Copyright (c) 2006</p>
* <p>Company: </p>
* @author not attributable
* @version 1.0
*/
public class QuickSort {

  public static void print(int[] number) {//打印输入数组内容
    for (int i = 0; i < number.length; i++) {
      System.out.print(number[i] + ",");
    }
    System.out.println("");
  }

  public static void swap(int[] number, int i, int j) {//交换number数组索引i,j处的值
    int tmp;
    tmp = number[i];
    number[i] = number[j];
    number[j] = tmp;
  }
  /**
   * 以左边元素为轴的快速排序
   * 解法:
   * 1.將最左邊的數設定為軸,並記錄其值為 s
   * 廻圈處理:
   * 2.令索引 i 從數列左方往右方找,直到找到大於 s 的數
   * 3.令索引 j 從數列右方往左方找,直到找到小於 s 的數
   * 4.如果 i >= j,則離開迴圈
   * 5.如果 i < j,則交換索引i與j兩處的值
   * 6.將左側的軸與 j 進行交換
   * 7.對軸左邊進行遞迴
   * 8.對軸右邊進行遞迴
   * 透過以下演算法,則軸左邊的值都會小於s,軸右邊的值都會大於s,如此再對軸左右兩邊進行遞迴,就可以對完成排序的目的
   * 例如下面的實例,*表示要交換的數,[]表示軸:
   * [41] 24 76* 11 45 64 21 69 19 36*
   * [41] 24 36 11 45* 64 21 69 19* 76
   * [41] 24 36 11 19 64* 21* 69 45 76
   * [41] 24 36 11 19 21 64 69 45 76
   * 21 24 36 11 19 [41] 64 69 45 76
   * 在上面的例子中,41左邊的值都比它小,而右邊的值都比它大,如此左右再進行遞迴至排序完成。
   *
   * @param number 排序数组
   * @param left  开始索引
   * @param right 结束索引
   */
  public static void sort(int[] number, int left, int right) {
    if (left < right) {
      int s = number[left];
      int i = left;
      int j = right + 1;
      int len = number.length;
      while (true) {
        while (i+1<len && number[++i] < s)// 向右找
          ;
        while (j-1>-1 && number[--j] > s)    // 向左找
          ;
        if (i >= j)
          break;
        swap(number, i, j);
        print(number);
      }
      number[left] = number[j];
      number[j] = s;
      sort(number, left, j - 1); // 對左邊進行遞迴
      sort(number, j + 1, right); // 對右邊進行遞迴
    }
  }
  /**
   * 以中间元素为轴的快速排序
   * 取中間的元素s作比較,同樣的先得右找比s大的索引 i,然後找比s小的索引 j,
   * 只要兩邊的索引還沒有交會,就交換 i 與 j 的元素值,這次不用再進行軸的交換了,因為在尋找交換的過程中
   * ,軸位置的元素也會參與交換的動作,例如:
   * 41 24 76 11 45 64 21 69 19 36
   * 首先left為0,right為9,(left+right)/2 = 4(取整數的商),所以軸為索引4的位置,
   * 比較的元素是45,您往右找比45大的,往左找比45小的進行交換:
   * 41 24 76* 11 [45] 64 21 69 19 *36
   * 41 24 36 11 45* 64 21 69 19* 76
   * 41 24 36 11 19 64* 21* 69 45 76
   * [41 24 36 11 19 21] [64 69 45 76]
   * 完成以上之後,再初別對左邊括號與右邊括號的部份進行遞迴,如此就可以完成排序的目的。
   * @param number
   * @param left
   * @param right
   */
  public static void sort1(int[] number, int left, int right) {
    if(left < right){
      int i = left -1 ;
      int j = right+1;
      int mid  = (left+right)>>>1;
      int s = number[mid];
      int len = number.length;
      while(true){
        while(i+1<len && number[++i] < s)//向右移
          ;
        while(j-1>-1 && number[--j] > s)//向左移
          ;
        if(i>j)
          break;
        swap(number,i,j);
        print(number);
      }
      sort1(number,left,j);
      sort1(number,i,right);
    }
  }
  public static void sort2(int[] number, int left, int right) {

  }
  public static void main(String[] args) {
    int[] number = {
        -6,-1};
    sort1(number, 0, number.length - 1);
  }
}

相关文章推荐

快速排序代码

  • 2016年06月14日 14:08
  • 2KB
  • 下载

简单的快速排序

  • 2015年01月23日 09:57
  • 479B
  • 下载

NSGA 2 学习笔记 -- 快速排序

NSGA 2 使用了随机快速排序算法。 C. A. R. Hoare在1962年为了改进冒泡排序算法提出快速排序(Quicksort)算法。其基本思想是递归、分治。其时间复杂度为Ο(n log n)...

快速排序算法

  • 2015年05月01日 16:41
  • 1KB
  • 下载

C#快速排序练习

  • 2017年06月20日 11:40
  • 30KB
  • 下载

经典算法—快速排序(Quicksort)使用详解

快速排序(Quicksort)是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部...
  • a125138
  • a125138
  • 2012年07月28日 17:31
  • 4002

快速排序原创数据(20组)

  • 2015年10月30日 21:48
  • 7.57MB
  • 下载

使用回调实现对一组任意类型的对象做快速排序

qsort函数实现对一组任意类型对象的排序,调用者提供 findPos_t 回调函数,在回调函数中实现对特定类型元素位置的查 // qsort.h #ifndef QSORT_H #define QS...
  • tzshlyt
  • tzshlyt
  • 2016年11月01日 15:02
  • 199

冒泡归并和快速排序java源码

  • 2016年05月11日 20:30
  • 2KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:快速排序(一)
举报原因:
原因补充:

(最多只允许输入30个字)