最高效能的排序法是哪个呢？？冒泡排序还是选择排序，还是插入排序呢？这些都不是，我们已经进入了高效的排序时代了——————快速排序法
快速排序法思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都小
  然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序法的效率是最高的！！！！！！！！！！！！！！！

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>

复制代码

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

快速排序不是一种稳定的排序方法。
归并排序和堆排序好像也能做到时间复杂度也是log2(n)*n。且归并是稳定的。
归并排序：log2(n)*n
堆排序：log2(n)*

效率最高？
对于不稳定排序算法，这要看样本究竟怎么样吧。虽然大多数情况下快排都很好。

然而Arrays.sort();解决了一切问题

代码的注释这么详细啊！辛苦了，谢谢分享

支持一下，看看

然而Arrays.sort();解决了一切问题，不过楼主还是很霸气的

学习了！~~~

回复赚点钱，我也不容易啊啊

Arrays.sort()就好了啊

快排，了解过，但没写过，谢谢分享！

学习了~

受教了，谢谢！

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

当样本出现重复元素的时候，就会造成结果不稳定的。你说的哪两种恕我没有看到过，可能如你所说

itheima_llt 发表于 2015-6-9 19:43
然而Arrays.sort();解决了一切问题

呵呵，确实如此啊，不过可以看看人家原码怎么写的

pizhihui 发表于 2015-6-9 20:21
代码的注释这么详细啊！辛苦了，谢谢分享

可不是吗，我是一行注释一行代码，注释都比代码多

主要是面试就会问这些，开发基本不用的吧

过来学习一下

还没有学到这呢

哈哈  我也想要点啊

过来看看    支持一下