常见排序(归并排序)

各种常用排序算法
类别	排序方法	时间复杂度			空间复杂度	稳定性	复杂性	特点
类别	排序方法	最好	平均	最坏	辅助存储		简单
插入排序	直接插入	O(N)	O(N²)	O(N²)	O(1)	稳定	简单
插入排序	希尔排序	O(N)	O(N^1.3)	O(N²)	O(1)	不稳定	复杂
选择排序	直接选择	O(N)	O(N²)	O(N²)	O(1)	不稳定
选择排序	堆排序	O(N*log₂N)	O(N*log₂N)	O(N*log₂N)	O(1)	不稳定	复杂
交换排序	冒泡排序	O(N)	O(N²)	O(N²)	O(1)	稳定	简单	1、冒泡排序是一种用时间换空间的排序方法，n小时好 2、最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序，最差时间复杂度O(N^2)只是表示其操作次数的数量级 3、最好的情况是数据本来就有序，复杂度为O(n)
交换排序	快速排序	O(N*log₂N)	O(N*log₂N)	O(N²)	O(log₂n)~O(n)	不稳定	复杂	1、n大时好，快速排序比较占用内存，内存随n的增大而增大，但却是效率高不稳定的排序算法。 2、划分之后一边是一个，一边是n-1个，这种极端情况的时间复杂度就是O(N^2) 3、最好的情况是每次都能均匀的划分序列，O(N*log₂N)
归并排序		O(N*log₂N)	O(N*log₂N)	O(N*log₂N)	O(n)	稳定	复杂	1、n大时好，归并比较占用内存，内存随n的增大而增大，但却是效率高且稳定的排序算法。
基数排序		O(d(r+n))	O(d(r+n))	O(d(r+n))	O(rd+n)	稳定	复杂
注：r代表关键字基数，d代表长度，n代表关键字个数


不稳定：

  选择排序（selection sort）— O(n2)

  快速排序（quicksort）— O(nlogn) 平均时间, O(n2) 最坏情况; 对于大的、乱序串列一般认为是最快的已知排序

  堆排序 （heapsort）— O(nlogn)

  希尔排序 （shell sort）— O(nlogn)

  基数排序（radix sort）— O(n·k); 需要 O(n) 额外存储空间 （K为特征个数）


  稳定：

  插入排序（insertion sort）— O(n2)

  冒泡排序（bubble sort） — O(n2)

  归并排序 （merge sort）— O(n log n); 需要 O(n) 额外存储空间

  二叉树排序（Binary tree sort） — O(nlogn); 需要 O(n) 额外存储空间

  计数排序  (counting sort) — O(n+k); 需要 O(n+k) 额外存储空间，k为序列中Max-Min+1

  桶排序 （bucket sort）— O(n); 需要 O(k) 额外存储空间

1、归并排序，将元素列表进行二分分解，直到不可再分(实际上最终分解到了单个元素上),然后将元素按照顺序一步步合并起来

a、数组-递归

 1 public class Main {
 2     public static void main(String[] args) {
 3         int [] d = new int[10];
 4         for(int i =0; i < 10; i++){
 5             d[i] = new Random().nextInt(10);
 6         }        
 7         System.out.println(Arrays.toString(d));
 8         sort(d);
 9         System.out.println(Arrays.toString(d));
10     }
11     
12     static void sort(int[] data){
13         sort_m(data, 0, data.length-1);
14     }
15 
16     static void sort_m(int[] data, int start, int end){
17         if(start < end){
18             int mid = (start + end)/2;
19             sort_m(data, start, mid);
20             sort_m(data, mid+1, end);
21             merge(data, start, mid, end);
22         }
23     }
24 
25     static void merge(int []d, int start, int mid, int end){
26         int [] res = new int[end - start + 1];
27         int i=0, j =start, k =mid+1;
28         while(j <= mid  && k <= end){
29             if(d[j] < d[k]){
30                 res[i++] = d[j++];
31             }else{
32                 res[i++] = d[k++];
33             }
34         }
35         if(start == 3 && end == 4) {
36             System.out.println();
37         }
38         while(j <= mid){
39             try {
40                 res[i++] = d[j++];                
41             }catch(Exception e) {
42                 e.printStackTrace();
43             }
44             
45         }        
46         while(k <= end){
47             res[i++] = d[k++];
48         }
49         System.arraycopy(res, 0, d, start, res.length);    
50     }

posted @ 2019-06-25 17:51 高少振阅读(174) 评论(0) 编辑收藏举报

刷新页面返回顶部

高少振

常见排序(归并排序)

公告