java中的排序方法

1. 冒泡排序: 效率O（N*N），比较N*N/2，交换N*N/4

Java代码  
  1. public void bubbleSort() {  
  2.     int[] arr = {1, 6, 3, 5, 10, 4};  
  3.     int arrLen = arr.length;  
  4.   
  5.     // 内层循环变量  
  6.     int in;  
  7.           
  8.     // 外层循环变量  
  9.     int out;  
  10.   
  11.     // 外层循环次数 = 列表长度 - 1  
  12.     for (out = arrLen - 1; out > 0; out -- ) {  
  13.   
  14.         // 内层循环总是从最前面开始  
  15.         // 依次与列表中每个元素比较  
  16.         // 排除已经比较过的值, out及其之后的值  
  17.         for (in = 0; in < out; in ++) {  
  18.   
  19.             // 当前排序方式为升序排序  
  20.             // 即: arr[0] < arr[1] < ... < arr[arr.length - 1]  
  21.             if (arr[in] > arr[in + 1]) {  
  22.                 // 每当遇到满足条件(当前值大于后一个值)时, 就交换值  
  23.                 swap(arr, in, in + 1);  
  24.             }  
  25.         }  
  26.     }  
  27. }  

2. 选择排序: 效率：O（N*N），比较N*N/2，交换<N

Java代码  收藏代码
  1. public void selectSort() {  
  2.     int[] a = {1, 6, 3, 5, 10, 4};  
  3.     int in;     // 内层循环控制  
  4.     int out;    // 外层循环次数  
  5.     int min;    // 最小值下标  
  6.   
  7.     // 外层循环次数 = 列表长度 - 1  
  8.     for(out=0, len = a.length - 1; out<len; out++) {  
  9.   
  10.         // 假设第一个总是最小值  
  11.         // 这一步相当于得到天平秤中其中一个盘中的砝码  
  12.         min=out;  
  13.   
  14.         // in=out+1 : 当前值无需与当前值比较  
  15.         for(in=out+1; in<nElems; in++)  
  16.   
  17.             // in下标所指定的值是天平秤中另一个砝码  
  18.             // 比较符号"<"就是称的规则  
  19.             // 当前需要的是较小的值放在左边, 即升序排序  
  20.             if(a[in]<a[min])  
  21.                 min=in;  
  22.   
  23.         // 自己与自己交换无任何意义  
  24.         if (out != min)  
  25.             swap(out,min);  
  26.     }  
  27. }  

3. 插入排序, 序列中部分有序时效率较高, 逆序排序效率几乎与冒泡无异. 效率：O（N*N）, 比较N*N/4，复制N*N/4

Java代码  收藏代码
  1. Public void InsertionSort() {  
  2.     int[] a = {3, 5, 7, 6, 10, 4};  
  3.   
  4.     // 外层循环次数 = 列表长度 - 1  
  5.     for(int out=1, len = a.length - 1; out<len; out++) {  
  6.         int temp=a[out]  
  7.         int in=out;  
  8.   
  9.         // 从左到右依次比较,   
  10.         // 其比较规则类似于冒泡,  
  11.         // 不同点在于每次排序列表长度都比上一次加1, 且结束条件是找到首个满足交换条件(a[in‐1]>temp)的值  
  12.         // 例如:  
  13.         //     当 out=3, tmp=6;时  
  14.         //     当前循环执行次数为2次  
  15.         while(in>0 && a[in‐1]<temp) {  
  16.             a[in]=a[in‐1];                
  17.             ‐‐in;  
  18.         }  
  19.   
  20.         // 如果当前值(tmp)比所有已排序(下标out以前)的值都小时, 则插入到列表首个位置(in=0)  
  21.         a[in]=temp;  
  22.     }  
  23. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xm1-ybtk/p/5111990.html