在很多地方看到快速排序什么的，但是不是太懂。这个方法能提高很高的效率吗？排序方法效率都差不多吧？

1) 若n较小(n <= 50)，则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多，因而当记录本身信息量较大时，用直接选择排序较好。
(2) 若文件的初始状态已按关键字基本有序，则选用直接插入或冒泡排序为宜。
(3) 若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。快速排序是目前基于比较的内部排序法中被认为是最好的方法。
(4) 在基于比较排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程，由此可以证明：当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlog2n)的时间。
(5) 当记录本身信息量较大时，为避免耗费大量时间移动记录，可以用链表作为存储结构。

其实冒泡排序啊，选择排序啊都是为了让你了解一些排序的过错和方法，工作开发中几乎不用，因为java中有自己定义的排序方法直接调用就行，比如：数组类型的有 Arrays.sort() ，类集型的有 Collections.sort()被排序的对象必须实现Comparable接口的compareTo方法 ，还有ArrayList  TreeSet   TreeMap 关键看你想怎么排序！

冒泡 和选择排序   我觉得 是 考你个人理解和区分能力的

1. package daydanmonth;
   
2. //排序的那些事，选择排序+冒泡排序
   
3. import java.util.*;//一个最方便 另加的  java内置功能
   
4. public class ArrayText {
   
5. 
   
6.         /**
   
7.          * 需求：从已有的数组从小到大依次排列
   
8.          * 方法：
   
9.          * 1：定义两个未知变量，通过for循环进行两个函数之间的两两依次进行对比，相对较大的元素 靠后排列
   
10.          * 2； 设置一个具有间隔符功能的函数，从而使输出的排列数组更加美观
    
11.          *
    
12.          *
    
13.          * 输出结果：
    
14.          * [1, 2, 3, 4, 2, 1, 2, 3, 4, 5, 6, 7, 3, 2, 2, 2, 21]
    
15.            [1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 6, 7, 21]
    
16.           
    
17.            [1, 2, 3, 4, 2, 1, 2, 3, 4, 5, 6, 7, 3, 2, 2, 2, 21]
    
18.            [1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 6, 7, 21]
    
19. 
    
20.            */
    
21. //数组的排序----选择排序:从数组第一个元素开始，和后面的元素对比，最小的排最前，与此类推
    
22.         public static void selectSort(int []arr)
    
23.         {
    
24.                 for(int x=0;x<arr.length;x++)
    
25.                 {
    
26.                         for(int y=x+1;y<arr.length;y++)//y代表位置相对靠后的元素
    
27.                         {
    
28.                                 if(arr[x]>arr[y])//如果想从大到小排列的话只需把>变成<
    
29.                                 {
    
30.                                         //int temp=arr[x];//定义一个中间值以便两变量互换位置
    
31.                                         //  arr[x]=arr[y];
    
32.                                           //arr[y]=temp;
    
33.                                        
    
34.                                          swap(arr,y,x);//利用函数功能进行  换位
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39.         public static void printArry(int[]arr)//为了美观设置一个关于间隔符号的函数
    
40.         {
    
41.                 System.out.print("[");
    
42.                 for(int x=0;x<arr.length;x++)
    
43.                 {
    
44.                         if(x!=arr.length-1)
    
45.                         {
    
46.                                 System.out.print(arr[x]+", ");
    
47.                                 }
    
48.                                 else
    
49.                                         System.out.print(arr[x]+"]");
    
50.                         }
    
51.                 System.out.println();
    
52.         }
    
53.         //冒泡排序法：选择排序:从数组前面开始，有顺序两两对比，最小的排最前，与此类推
    
54.                 public static void bubbleSort(int []arr)
    
55.                 {
    
56.                         for(int x=0;x<arr.length-1;x++)
    
57.                         {
    
58.                                 for(int y=0;y<arr.length-x-1;y++)
    
59.                                 {
    
60.                                         if(arr[y]>arr[y+1])//如果想从大到小排列的话只需把>变成<
    
61.                                         {
    
62.                                                 //int temp=arr[y];//定义一个中间值以便两变量互换位置
    
63.                                                  // arr[y]=arr[y+1];
    
64.                                                  // arr[y+1]=temp;
    
65.                                                   
    
66.                                                   
    
67.                                                   swap(arr,y,y+1);//利用函数功能进行换位
    
68.                                 }
    
69.                         }
    
70.                 }
    
71.         }
    
72.                
    
73.                 //换位置函数功能
    
74.                 public static void swap(int[]arr,int a,int b)
    
75.                 {
    
76.                         int temd=arr[a];
    
77.                         arr[a]=arr[b];
    
78.                         arr[b]=temd;
    
79.                 }
    
80. public static void main(String[] args)
    
81. {
    
82.                 int arr[]={15,2,3,4,2,1,2,3,4,5,6,7,3,2,2,2,21};
    
83.                
    
84.                 System.out.print("排列前：         ");
    
85.                 printArry(arr);//排列前
    
86.                
    
87.                 System.out.print("选择排序法：");
    
88.                 selectSort(arr);//进行排列
    
89.                 printArry(arr);//排列后
    
90.                
    
91.                 System.out.print("冒泡排序法：");
    
92.                 bubbleSort(arr);
    
93.                 printArry(arr);//排列后
    
94.                
    
95.                 System.out.print("Arrays.sort--Java内置排序：");
    
96.                 System.out.println();
    
97.                 Arrays.sort(arr);
    
98.                 printArry(arr);
    
99.                
    
100.                
     
101.                
     
102.                 }
     
103.         }
     
104.          
     
105. 
     
106.        

复制代码

但是在日常开发中  一般用 ArrayList  TreeSet   TreeMap 之类的，，毕竟人家都已经封装好了   你直接拿出来用就行了   这也是面向对象的精华所在  哈