一直没搞清楚有几种，我就记得就一种冒泡，今天同学跟我说了个插入排序！不明白，请告诉解答：

我知道大概是三种：冒泡排序 排序方法相邻两元素进行比较如有需要则进行交换 每完成一次循环就将最大元素排在最后如从小到大排序 下一次循环是将其他的数进行类似操作。 优点 – 若数据已有部分排好序则使用冒泡排序法可以很快的完成排序。 缺点 – 会造成反复扫描数据比较相邻的两个数据速度不快也没有效率。   插入排序 排序方法每一趟从待排序的数据元素中选出最小或最大的一个元素 顺序放在已排好序的数列的最后 直到全部待排序的数据元素排完。 优点 – 最简单的排序 缺点 – 比其他排序消耗时间多   选择排序 排序方法将一个记录插入到已排好序的有序表有可能是空表中, 从而得到一个新的记录数增1的有序表 优点 – 利用一个一个的元素的插入比较将元素放入适当的位置也属于简单排序 缺点 – 但是每次都与之前数据相比较故耗费时间  

JAVA里 操作数组进行排序功能，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。

要掌握的有选择排序和冒泡排序，冒泡排序经常在笔试题里出现，我们大多数都是用选择排序；
排序方法还有很多种，只是不要求掌握，什么快速排序、希尔排序、插入排序！

1.快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现
2.冒泡法是运用遍历数组进行比较，用的比较多，大家都应该很熟悉了，通过不断的比较将最小值或者最大值一个一个的遍历出来。
3.选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组
4.插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

效率最高的是for循环嵌套中，创建临时变量temp及index保存较大或较小值，直到比较结束再按照角标对换。

简单一点说 插入排序就跟视频里的二分查找法原理一样,前提必须是这个数组有序

希望对你有所帮助

排序方法不是java的内容，是关于算法的内容，算法是不局限于哪一种编程语言的，任何一种语言都通用。
而且排序算法有很多种的，例如选择排序，冒泡排序，插入排序，对象排序，快速排序等都是简单的排序，还有很多复杂的排序，不可能穷举完，建议你以后看看数据结构和算法方面的书籍。
下面的代码分别给出了冒泡排序，选择排序的java实现示例代码，希望对你有帮助

1. public class ArrayTool
   
2. {
   
3.         /**
   
4.         空构造函数
   
5.         */
   
6.         private ArrayTool(){}
   
7.         /**
   
8.         获取一个整型数组的最大值
   
9.         @param arr 接收一个int类型的数组
   
10.         @return        会返回数组中的最大值
    
11.         */
    
12.         public static int getMax(int[] arr)
    
13.         {
    
14.                 int max=0;
    
15.                 for(int i=1;i<arr.length;i++)
    
16.                 {
    
17.                         if(arr[i]>arr[max])
    
18.                                 max=i;
    
19.                 }
    
20.                 return arr[max];
    
21.         }
    
22.         /**
    
23.         获取一个整型数组的最小值
    
24.         @param arr 接收一个int类型的数组
    
25.         @return        会返回数组中的最小值
    
26.         */
    
27.         public static int getMin(int[] arr)
    
28.         {
    
29.                 int min=0;
    
30.                 for(int i=1;i<arr.length;i++)
    
31.                 {
    
32.                         if(arr[i]<arr[min])
    
33.                                 min=i;
    
34.                 }
    
35.                 return arr[min];
    
36.         }
    
37.         /**
    
38.         给int数组进行选择排序
    
39.         @param arr 接收一个int类型的数组
    
40.         */
    
41.         public static void selectionSort(int[] arr)
    
42.         {
    
43.                 for(int i=0;i<arr.length-1;i++)
    
44.                 {
    
45.                         for(int j=i+1;j<arr.length;j++)
    
46.                         {
    
47.                                 if(arr[i]>arr[j])
    
48.                                 {
    
49.                                         swap(arr,i,j);                               
    
50.                                 }
    
51.                         }
    
52.                 }
    
53.         }
    
54.         /**
    
55.         给int数组进行冒泡排序
    
56.         @param arr 接收一个int类型的数组
    
57.         */
    
58.         public static void bubbleSort(int[] arr)
    
59.         {
    
60.                 for(int i=0;i<arr.length-1;i++)
    
61.                 {
    
62.                         for(int j=i+1;j<arr.length-i-1;j++)
    
63.                         {
    
64.                                 if(arr[j]>arr[j+1])
    
65.                                 {
    
66.                                         swap(arr,j,j+1);
    
67.                                 }
    
68.                         }
    
69.                 }
    
70.         }
    
71.         /**
    
72.         给数组中的元素进行位置置换
    
73.         @param arr 接收一个int类型的数组
    
74.         @param a 要置换的位置
    
75.         @param b 要置换的位置
    
76.         */
    
77.         private static void swap(int[] arr,int a,int b)
    
78.         {
    
79.                 int temp=arr[a];
    
80.                 arr[a]=arr[b];
    
81.                 arr[b]=temp;
    
82.         }
    
83.         /**
    
84.         用于打印数组中的元素，格式是：[element1,element2,...]
    
85.         */
    
86.         public static void printArray(int[] arr)
    
87.         {
    
88.                 System.out.print("[ ");
    
89.         for(int i=0;i<arr.length;i++)
    
90.                 {
    
91.                         if(i!=arr.length-1)
    
92.                                 System.out.print(arr[i]+", ");
    
93.                         else
    
94.                                 System.out.println(arr[i]+"]");
    
95.                 }
    
96.         }
    
97. }

复制代码

说明：这里代码没有给出插入排序，对象排序，快速排序，希望你有空去查查。
       一般情况下几乎不用冒泡（我没考虑用在项目中），它过于简单，只有当数据量很小的时候（如上面的示例代码）它会有些应用价值。
       选择排序虽然把交换次数降到了最低，但比较的次数仍然很大，但数据量小时，可以用选择排序；
       假如当数量比较小且基本有序时，插入排序时比较快的；
       但是对于大数据量的排序来说，快速排序通常是最快的方法。

这是我在本板块以前发的帖子，是数组排序方法的汇总，希望对你有帮助！！
http://bbs.itheima.com/thread-39420-1-1.html

哥们，有多少种排序不是JAVA规定的，都是人想出来的，给你5个数， 4，3，7，9，1   你用你的数学思想去想想用什么办法可以排序，然后你用文字表达出来

之后你再把你的这个人类语言文字用计算机语言文字的方式体现出来

最后你再去看看JAVA中把你的这些排序思想取名叫做什么排序！

开发就是直接调用Arrays.sort()　　但是要加载import java.util.* ;包加在类前 注意不加载包会报错
其他的折半查找，插入，冒泡，选择等方法就是用来面试的
这些方法一般教材和网上都有

给你一个快速排序的例子，我想了一天才搞懂的。

1. package com.itheima;
   
2. 
   
3. public class Test2 {
   
4. 
   
5.         /**
   
6.          * 2、 排序有哪几种方法？请列举。并用JAVA实现一个快速排序.
   
7.          */
   
8.        
   
9.         //排序方法有：  冒泡排序，直接插入排序，快速排序，简单选择排序，希尔排序，堆排序。
   
10. 
    
11.         public static void main(String[] args) {
    
12.                 //定义整形数组
    
13.                 int[] pData=new int[]{66,46,25,99,74,21,93,48};
    
14.                 //调用快速排序法
    
15.                 quickSort(pData,0, pData.length);
    
16.                 //调用打印方法
    
17.                 print(pData);
    
18. 
    
19.         }
    
20.        
    
21.         //快速排序法
    
22.         public static void quickSort(int[] pData,int left,int right)
    
23.         {
    
24.                 //定义局部变量
    
25.                 int i,j;
    
26.                 int middle,temp;
    
27.                 i = left;
    
28.                 j = right;
    
29.                 middle = pData[left];
    
30.                 //一次快速排序
    
31.                 while(true){
    
32.                         //从第二个数开始找大于中枢的数 ,从前面开始找大于pData[left]的数
    
33.                         while((++i)<right && pData[i]<middle);
    
34.                          //从最后一个数开始找第一个小于中枢pData[left]的数
    
35.                         while((j--)>left && pData[j]>middle);
    
36.                 if(i>=j)
    
37.                         break;
    
38.                     //交换两边找到的数  
    
39.                         temp = pData[i] ;
    
40.                 pData[i] = pData[j] ;
    
41.                 pData[j] = temp ;
    
42.                 
    
43.                 }
    
44.                  //交换中枢
    
45.                  pData[left] = pData[j] ;
    
46.              pData[j] = middle ;
    
47.              //递归快排中枢左边的数据
    
48.              if(left<j)
    
49.               quickSort(pData,left,j) ;
    
50.             //递归快排中枢右边的数据
    
51.              if(right>i)
    
52.               quickSort(pData,i,right) ;
    
53.         }
    
54.        
    
55.        
    
56.         public static void print(int[] pData){
    
57.                 for(int num: pData){
    
58.                         System.out.print(num+",");
    
59.                 }
    
60.         }
    
61. }

复制代码