Java--排序算法

写算法的时候顺便把八大排序整理了一下，跟大家分享一下，写的不好，希望大神批评指正。（参考数据结构）

这里是同学推荐的视频（http://www.cnbeta.com/articles/tech/202221.htm），感觉很不错，对于刚学的人来说，看完视频再看代码应该很好理解了，不过就是一下看好几个再加上里面···的音乐，估计有点儿喘不过气，总之还是很清晰的，自己感受吧。

评价算法的指标是：时间、空间和稳定性。

算法特点：

算法名称 时间复杂度 空间复杂度 稳定性
直接插入 O（n2） O(1) √
希尔排序 n→∞ O(n(log2n2)) O(1) ×
冒泡排序 O（n2） O(1) √
快速排序 O（nlog2n)
好：O（log2n）

坏：O(n)

×
选择排序 O（n2） O(1)
算法本身是稳定的

采用“交换记录”策略会造成不稳定现象的产生

堆排序 O（nlog2n） O(1) ×
归并排序 O（nlog2n） O(n) √
基数排序 O（d(n+rd)） O(n+rd) √

直接插入排序，是当待排序的记录个数比较少并且排序序列的关键字基本有序时，效率较高。

通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应的位置并插入。（在具体实现的时候，可以将list[i]从前向后插入比较，也可以从后向前插入比较。这里采用的是从后向前插入比较）

 1 public class Main { 2  3 　　/*插入排序*/ 4 　　public static int[] insert_sort(int[] list){     5 　　　　int j,temp; 6 　　　　for (int i = 0; i < list.length; i++) { 7 　　　　　　j = i - 1; 8 　　　　　　temp = list[i]; 9 　　　　　　while (j >= 0) {10 　　　　　　　　if (temp < list[j]) {11 　　　　　　　　　　list[j+1] = list[j];12 　　　　　　　　　　list[j] = temp;13 　　　　　　　　}14 　　　　　　j = j-1;    15 　　　　　　}16 　　　　}17 　　return list;    18 　　}19 20 　　public static void main(String[] args) {21 　　　　int[] list = new int[]{49,38,65,97,76,13,27,49,55,04};22 　　　　int[] result = new int[list.length];23 　　　　result = insert_sort(list);24 　　　　System.out.println("插入排序：");25 　　　　for (int i = 0; i < result.length; i++) {26 　　　　　　System.out.print(result[i] + ",");    27 　　　　}28 　　}29 }

注：main函数的调用就写上面的一个，下面就不再写了，毕竟这个大家都可以。

希尔排序又称“缩小增量排序”，也是插入排序的一种。希尔排序实质上是采用分组插入的方法。先将待排序记录序列分割成几组，对每组进行直接插入，然后增加每组的数据量重新分组。就这样经过几次分组排序之后，整个序列基本有序，最后再进行一次直接插入排序。

 1 /*希尔排序*/ 2 public static int[] shell_sort(int[] list){ 3 　　int j,temp,k; 4 　　int group = list.length/2; 5  6 　　while (group>0) { 7 　　　　for (int i = 0; i < group; i++) { 8 　　　　　　j = i + group; 9 　　　　　　while (j <list.length) {10 　　　　　　　　temp = list[j];11 　　　　　　　　k = j-group;12 　　　　　　　　while (k >= 0) {13 　　　　　　　　　　if (list[k] > temp) {14 　　　　　　　　　　　　list[k+group] = list[k];   //记录后移，直到找到插入位置15 　　　　　　　　　　　　list[k] = temp;16 　　　　　　　　　　}17 　　　　　　　　　　k = k - group;18 　　　　　　　　}19 　　　　　　j = j + group;    　　    20 　　　　　　}    21 　　　　}22 　　　　group = group / 2;23 　　}    24 　　return list;    25 }

简单选择排序

 1 /*简单选择排序*/ 2     public static int[] select_sort(int[] list){ 3          4         int min = list[0],temp; 5          6         for (int i = 0; i < list.length; i++) { 7             if (list[i] < min) { 8                 min = list[i]; 9             }10         }11         12         return list; 13     }

冒泡排序是一种最简单的交换排序方法，是通过两两比较相邻记录的关键词，如果发生逆序，就交换。从而使关键字小的记录就行气泡一样逐渐往上“漂浮”或者是较大的像石块一样“坠落”。当n较大时（数据长度较大）不宜采用此算法。

 1 /*冒泡排序*/ 2     public static int[] bubble_sort(int[] list){ 3         int temp; 4         for (int i = 0; i < list.length; i++) { 5             for (int j = i+1; j < list.length; j++) { 6                 if (list[i] > list[j]) { 7                     temp = list[i]; 8                     list[i] = list[j]; 9                     list[j] = temp;    10                 }        11             }            12         }        13         return list;14     } ```

 1 /*快速排序*/ 2     public static int[] quick_sort(int[] list,int left,int right) { 3         int temp,low,high; 4         if (left >= right) { 5             return list; 6         } 7         temp = list[left]; 8         low = left; 9         high = right;10         11         while (left < right) {12             while (left < right && list[right] >= temp) {13                 right -= 1;                14             }15             list[left] = list[right];16             while (left < right && list[left] <= temp) {17                 left += 1;                18             }19             list[right] = temp;20             quick_sort(list, low, left - 1);21             quick_sort(list, left + 1, high);22         }23         return list;        24     }

 1 /*归并排序*/ 2     public static int[] merge(int[] left,int[] right) { 3          4         int i=0,j=0; 5         int[] result; 6         while (i < left.length && j < right.length) { 7             if (left[i] <= right[j]) { 8                 result.append(left[i]); 9                 i += 1;10             }else{11                 result.append(right[j]);12                 j += 113             }14             15         }16         17         return result;18         19     }