大师兄咚咚咚

排序算法比较

本文代码参考https://blog.csdn.net/zgrjkflmkyc/article/details/11639091

一、冒泡排序

　　1. 原理

　　2. 代码实现

 1     public void bubbleSort(int[] ele) {
 2         int len = ele.length;
 3         //outer loop
 4         for (int out = len - 1; out > 1; out--) {
 5             //inner loop
 6             for(int in = 0; in < out; in++) {
 7                 if (ele[in] > ele[in +1 ]) {
 8                     swap(ele[in], ele[in + 1]);
 9                 }
10             }
11         }
12     }
13     
14     public void swap(int a, int b) {
15         
16         int deliver = a;
17         a = b;
18         b = deliver;
19     }
20

　　3. 复杂度分析

　　交换次数的复杂度为O(n2)，比较次数的复杂度为O(n2)。

二、选择排序

　　1. 原理

　　2. 代码实现

 1     public void selectionSort (int[] ele) {
 2         int len = ele.length;
 3         int min = 0;
 4         for (int out = 0; out < len - 1; out++) {
 5             min = out;
 6             for (int in = out + 1; in < len - 1; in++) {
 7                 if (ele[in] < ele[min]) {
 8                     min = in;
 9                 }
10             }
11             swap(ele[min],ele[out]);
12         }
13         
14     }
15     
16     public void swap(int a, int b) {
17         int mid = a;
18         a = b;
19         b = mid;
20         
21     }

　　3. 复杂度分析

　　交换次数的复杂度为O(n)（由于只需要与最小值进行交换），比较次数的复杂度为O(n2)。

三、插入排序

　　1. 原理

　　2. 代码实现

 1     public void insertSort(int[] ele) {
 2         int len = ele.length;
 3         //out表示未排序的最左端的元素
 4         for (int out = 1; out < len; out++) {
 5             int tmp = ele[out];//存储出列元素
 6             //in从out处向左移动，直到元素不大于tmp
 7             int in = out;
 8             while (in > 0 && ele[in - 1] > ele[out]) {
 9                 ele[in-1] = ele[in];
10                 --in;
11             }
12             ele[in] = tmp;
13         }
14         
15     }

　　3. 复杂度分析

　　比较次数的复杂度为O(n2)，但是它比冒泡排序快近一倍，比选择排序也要快。

四、快速排序

　　1. 原理

　　2. 代码实现

/*-----------------------快速排序法--------------------------------------------- 
    在这个例子中，取中间的元素s作比较，同样的先得右找比s大的索引i，然后找比s小的 
    索引j，只要两边的索引还没有交会，就交换i 与j 的元素值，这次不用再进行轴的交换了， 
    因为在寻找交换的过程中，轴位置的元素也会参与交换的动作，例如： 
    41 24 76 11 45 64 21 69 19 36 
    首先left为0，right为9，(left+right)/2 = 4（取整数的商），所以轴为索引4的位置，比较的元素是 
    45，您往右找比45大的，往左找比45小的进行交换： 
    41 24 76* 11 [45] 64 21 69 19 *36 
    41 24 36 11 45* 64 21 69 19* 76 
    41 24 36 11 19 64* 21* 69 45 76 
   [41 24 36 11 19 21] [64 69 45 76] 
    完成以上之后，再初别对左边括号与右边括号的部份进行递回，如此就可以完成排序的目的。 
   --------------------------------------------------------------------------------*/  
 1    public void quicksort_2(int number[], int left, int right) {  
 2        int i, j, s, temp;  
 3        if(left < right) {  
 4            s = number[(left+right)/2];  
 5            i = left - 1;  
 6            j = right + 1;  
 7            while(true) {  
 8                while(number[++i] < s) ; // 向右找  
 9                while(number[--j] > s) ; // 向左找  
10                if(i >= j)  
11                    break;  
12                temp=number[i];  
13                number[i]=number[j];  
14                number[j]=temp;  
15            }  
16        quicksort_2(number, left, i-1); // 对左边进行递回  
17        quicksort_2(number, j+1, right); // 对右边进行递回  
18        }  
19    }

　　3. 复杂度分析

　　O(n*logn)

五、算法对比分析

　　1. 一般情形下几乎不使用冒泡排序，复杂度比较高。

　　2. 当交换相对于比较更加耗时的时候，可以采用选择排序。

　　3. 对于数据量比较小或者基本有序的情况，通常采用插入排序。

　　4. 对于数据量比较大的情形，通常采用快速排序。

六、总结

posted on 2018-03-29 16:17  大师兄咚咚咚  阅读(119)  评论(0)  编辑  收藏  举报

导航