常见排序算法_java版本

来源:互联网 发布:深入理解java反射机制 编辑:程序博客网 时间:2024/06/05 23:35
  1. publicclassArraySort

  2. {

  3. /**

  4. * 自1开始,通过交换将i插入其左端的有序的数列中。

  5. * 交换次数不确定,但比较次数较均衡。

  6. * 比冒泡更优。

  7. * @param x

  8. *            数组

  9. * @param off

  10. *            起始下标

  11. * @param len

  12. *            长度

  13. */

  14. privatestaticvoid charu(int x[],int off,int len)

  15. {

  16.  for(int i = off; i < len+ off; i++)

  17.    for(int j = i; j > off&& x[j-1]> x[j]; j--)

  18.     swap(x, j, j-1);

  19. }

  20. /**

  21. * 与冒泡相似,每一趟找到自i到末端最小的数的index,然后与i交换

  22. * 一趟只需一次交换,所以比冒泡快

  23. */

  24. privatestaticvoid xuanze(int x[],int off,int len)

  25. {

  26.  for(int i = off; i < len+ off; i++){

  27.    int min= i;

  28.    for(int j = min; j<len+off; j++){

  29.     if(x[min]>x[j])

  30.      min=j;

  31.    }

  32.    swap(x, i, min);

  33.  }

  34. }

  35. /**

  36. * i从左至右,i定住时将自i到末端最小的数移至i处,完成一趟,以此类推直至i到最右端

  37. * 通过不停交换完成,时间消耗较多

  38. */

  39. privatestaticvoid maopao(int x[],int off,int len)

  40. {

  41.  for(int i = off; i < len+ off-1; i++){  

  42.    for(int j = i; j<len+off; j++){

  43.     if(x[i]>x[j])

  44.      swap(x, i, j);

  45.    }

  46.  }

  47. }

  48. /**

  49. * 快速排序法:首先任意选取一个数据作为关键数据,然后将所有比它小的数都放到它前面,

  50. * 所有比它大的数都放到它后面,这个过程称为一趟快速排序。之后递归。

  51. * 算法:

  52. * 1)i从左到右找比key大的,i移至此处;j从右到左找比key小的,j移至此处

  53. * 2)若i<j则交换ij,重复1);否则,一趟完成

  54. * 3)一趟完成之后i如果未到最右端,递归右端;j如果未到达最左端,递归左端

  55. * 此算法可改进,请参详jdk源码。

  56. */

  57. privatestaticvoid kuaisu(int x[],int off,int len)

  58. {

  59.  int m= off+(len>>1);// 中位下标

  60.  int left= off;// 起始下标

  61.  int right= off+ len-1;// 结束下标

  62.   m = med3(x, left, m, right);

  63.  int key= x[m];// 取中间的那个作为关键数据

  64.  // System.out.println("key="+key);

  65.  int i= left;

  66.  int j= right;

  67.  while(true)

  68.  {

  69.    while((x[i]< key)&&(i< right))

  70.     // 从左到右找>=的

  71.     i++;

  72.    while((x[j]> key)&&(j> left))

  73.     // 从右到左找<=的

  74.     j--;

  75.    if(i>= j)

  76.    {

  77.     break;//一趟完成

  78.    }

  79.    swap(x, i, j);

  80.    System.out.printf("swap %d %d:%s/n", i, j,Arrays.toString(x));

  81.  }

  82.  if(i< right)

  83.    kuaisu(x, i +1, right - i);

  84.  if(j> left)

  85.    kuaisu(x, left, j- left);

  86. }

  87. /**

  88. * 求数值处于中间的下标

  89. */

  90. privatestaticint med3(int x[],int a,int b,int c)

  91. {

  92.  return(x[a]< x[b]?(x[b]< x[c]? b: x[a]< x[c]? c: a)

  93.     :(x[b]> x[c]? b: x[a]> x[c]? c: a));

  94. }

  95. /** 在数组x中交换a b位置 */

  96. privatestaticvoid swap(int x[],int a,int b)

  97. {

  98.  int t= x[a];

  99.   x[a]= x[b];

  100.   x[b]= t;

  101. }

  102. publicstaticvoid main(String[] args)

  103. {

  104.  int[] x =

  105.  {49,38,65,97,76,13,27,12,18,54,20,9,8,5,6};

  106.  System.out.println("begin..."+Arrays.toString(x));

  107. /*

  108. maopao(x, 0, x.length);

  109.   xuanze(x, 0, x.length);

  110.   charu(x, 0, x.length);

  111. */

  112.   kuaisu(x,0, x.length);

  113.  System.out.println("final..."+Arrays.toString(x));

  114. }

  115. }

0 0
原创粉丝点击