黑马程序员技术交流社区

标题: 最高效的排序法,什么冒泡啊,选择啊,靠边站 [打印本页]

作者: java8023    时间: 2015-6-9 19:03
标题: 最高效的排序法,什么冒泡啊,选择啊,靠边站
最高效能的排序法是哪个呢??冒泡排序还是选择排序,还是插入排序呢?这些都不是,我们已经进入了高效的排序时代了——————快速排序法
快速排序法思想:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都小
  然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序法的效率是最高的!!!!!!!!!!!!!!!


  1. <p>class Test1 {
  2.           public static void main(String[] args) {
  3.           // 定义一个任意数组
  4.                     int[] arr = { 34, 3, 53, 2, 23, 7, 14, 10 };
  5.                    // 选择用快速排序法,定义方法的初始的形式参数
  6.                   // 数组的上边界
  7.                      int low = 0;
  8.                      // 数组的下边界
  9.                      int high = arr.length - 1;
  10.                     // 调用方法,传入参数
  11.                      quickSort(arr, low, high);
  12.                     //遍历数组打印
  13.                     for(int n:arr){
  14.                         System.out.print(n+",");
  15.              }
  16. }</p>
复制代码
  1. <p> public static void quickSort(int[] arr, int lowNum, int highNum) {
  2.           //当两个边界重合的时候,就停止递归
  3.            if(lowNum>=highNum)
  4.                 return;   
  5.           //根据快速排序法的原理选取数组的第一个元素作为参照元素
  6.            int mid = arr[lowNum];
  7.            int low = lowNum;
  8.            int high = highNum;
  9.             // 第一个元素作为参照循环比较之后的元素,完成排序
  10.               while (low < high) { // 只要最小的角标小于最大的就是说本段的数组的排序没有完成
  11.                // 先从数组的最后变开始向前遍历
  12.                           while (low < high&&arr[high] >= mid)
  13.                          // 自后向前遍历,直到遇到比中中轴值小的元素
  14.                                     high--; // 向前遍历,索引值减1
  15.                                      // 遇到比temp小的值就会停止循环,并且交换数值
  16.                             if(low<high){
  17.                                    //int temp=arr[low];
  18.                                    arr[low] = arr[high]; // 高效的交换方式,不用担心,arr[low]上的元素被覆盖,因为temp中还有此中轴值
  19.                                    //arr[high]=temp;       // 减少交换次数,提高效率
  20.                               }
  21.    
  22.                             // 从数组的前段开始遍历,向后遍历,low变化
  23.                              while (low < high && arr[low]<=mid)
  24.                               // 当low和high没有重合,并且前面的值都小于中轴值的时候遍历继续
  25.                                            low++; // 循环控制元素,做向后遍历
  26.                               // 当不满足条件,也就是说在前段找到了比temp大的值,停止循环,交换元素
  27.                              if(low<high){
  28.                                        //int temp=arr[high];
  29.                                        arr[high] = arr[low]; // 将此值和中轴所在位置的元素交换,此为高效写法,减少交换次数,提高效率
  30.                                       //arr[low]=temp;     // arr[high]中的值已经存放在最前端了
  31.                                  }
  32.    
  33.    
  34.                                  // 此时的low和high还没有重合,也就是说还没有完成一次完整的排序,必须借助循环
  35.                                 // 让中轴值所在的位置之前的所有元素都比其小,位置之后的元素都比其大</p><p>                          }
  36.                           // 循环停止,也就是说此时low和high重合,即low=high,已经完成了一次完整的排序
  37.                       //将中轴值赋值
  38.                        arr[low]=mid;
  39.   
  40.                       // 那么以中轴为界,将数组在分为两组,继续排序
  41.                       // 对于两边的数组递归调用方法quickSort(),直到完成排序</p><p>                      // 对于前面一组的数组,前段值和后端值     
  42.                      quickSort(arr, lowNum, low - 1);
  43.                      // 对于后面一组数组
  44.                     quickSort(arr, low + 1, highNum);  
  45.            }
  46. }</p>
复制代码

研究了很长时间的,终于写出来了,思想是一样,就是写法不一样,其他的很多都是两个方法,我只用了一个。使用递归,一定要注意结束条件,不然那酸爽你懂的!!!



作者: ETOLIA    时间: 2015-6-9 19:18
快速排序不是一种稳定的排序方法。
归并排序和堆排序好像也能做到时间复杂度也是log2(n)*n。且归并是稳定的。
归并排序:log2(n)*n
堆排序:log2(n)*

效率最高?
对于不稳定排序算法,这要看样本究竟怎么样吧。虽然大多数情况下快排都很好。
作者: itheima_llt    时间: 2015-6-9 19:43
然而Arrays.sort();解决了一切问题
作者: pizhihui    时间: 2015-6-9 20:21
代码的注释这么详细啊!辛苦了,谢谢分享
作者: 小车车    时间: 2015-6-9 21:21
支持一下,看看
作者: 付欢    时间: 2015-6-9 21:30
然而Arrays.sort();解决了一切问题,不过楼主还是很霸气的
作者: wwb1105    时间: 2015-6-9 21:37
学习了!~~~
作者: 西北风    时间: 2015-6-9 22:07
回复赚点钱,我也不容易啊啊
作者: msxhm    时间: 2015-6-9 22:33
Arrays.sort()就好了啊
作者: 郝民杰    时间: 2015-6-9 22:38
快排,了解过,但没写过,谢谢分享!
作者: DAN66    时间: 2015-6-9 22:40
学习了~
作者: 微尘爱笑    时间: 2015-6-9 22:44
受教了,谢谢!
作者: java8023    时间: 2015-6-10 00:39
ETOLIA 发表于 2015-6-9 19:18
快速排序不是一种稳定的排序方法。
归并排序和堆排序好像也能做到时间复杂度也是log2(n)*n。且归并是稳定的 ...

当样本出现重复元素的时候,就会造成结果不稳定的。你说的哪两种恕我没有看到过,可能如你所说
作者: java8023    时间: 2015-6-10 00:40
itheima_llt 发表于 2015-6-9 19:43
然而Arrays.sort();解决了一切问题

呵呵,确实如此啊,不过可以看看人家原码怎么写的
作者: java8023    时间: 2015-6-10 00:41
pizhihui 发表于 2015-6-9 20:21
代码的注释这么详细啊!辛苦了,谢谢分享

可不是吗,我是一行注释一行代码,注释都比代码多
作者: jjyy1008    时间: 2015-6-10 00:47
主要是面试就会问这些,开发基本不用的吧
作者: FTD-2009    时间: 2015-6-10 10:48
过来学习一下
作者: 悦鹏    时间: 2015-6-10 11:07
还没有学到这呢
作者: 杜弦东.    时间: 2015-6-10 11:20
哈哈  我也想要点啊
作者: 十字天堂    时间: 2015-6-10 12:29
过来看看    支持一下
作者: 许文搏    时间: 2015-6-10 14:47
itheima_llt 发表于 2015-6-9 19:43
然而Arrays.sort();解决了一切问题

哈哈哈~~~~~~~~~~~~
作者: 仲德明    时间: 2015-6-10 17:27
嗯,在书上看过这个算法!
作者: 雪域星辰    时间: 2015-6-10 18:02
怎么这么多啊。。。
作者: java8023    时间: 2015-6-10 20:56
仲德明 发表于 2015-6-10 17:27
嗯,在书上看过这个算法!

所以要好好学习下
作者: 痞子刘忙    时间: 2015-6-10 21:59
思路很好,学习了
作者: candy_xue    时间: 2015-6-10 22:05
哇塞  大神  居然能自己研究出来  我拜读过 排序方法   这种方法很难理解   不过确实处理大量数据时候很有优势
作者: yang2015    时间: 2015-6-10 22:18
学习学习。。。
作者: 一休    时间: 2015-6-10 22:22
辛苦了   有思想  
作者: 拐子    时间: 2015-6-10 22:22
学习了  哈哈  牛掰
作者: java8023    时间: 2015-6-13 21:03
今天看了一下同学的比较,算法还是思想比较重要
作者: 13569403973    时间: 2015-6-13 21:31
不错,可以看看!
作者: GoldMan    时间: 2015-6-13 21:36
学习了,不错,多谢楼主分享




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2