几种常用排序

目录(?)[+]

1，插入排序

原理类似于取扑克牌，从牌堆里取出扑克牌和手里的牌比较后，按照次序放好。java实现代码，最开始为了模拟取牌过程，设置了两个数组，后来改为一个，因为每次操作都不会过哨兵值K的位置。

[java]  view plain copy

1. import java.util.Scanner;  
2.   
3.   
4. public class InsertSortDemo {  
5.     public static void main(String args[]){  
6.         Scanner scanner=new Scanner(System.in);  
7.         int a[] = null,index=0;  
8.         String numstr[]=scanner.nextLine().split(" ");  
9.         a=new int[numstr.length];  
10.         for(String num:numstr){  
11.             a[index++]=Integer.parseInt(num);  
12.         }  
13.         int k;  
14.         for(int j=1;j<a.length;j++){  
15.             k=a[j];  //哨兵位置  
16.             int i=j-1;   //哨兵位置以前的那个位置  
17.             while(i>=0&&a[i]>k){   //逐次和前面的值比较  
18.                 a[i+1]=a[i];   //移动a[i]到a[i+1]的位置  
19.                 i--;  
20.             }  
21.             a[i+1]=k;   //找到合适的位置并插入  
22.         }   
23.         for(int y:a){  
24.             System.out.print(y+ " ");  
25.         }  
26.     }  
27. }  

1.1折半插入排序

在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low]，末元素设置为a[high]，则轮比较时将待插入元素与a[m]，其中m=(low+high)/2相比较,如果比参考元素大，则选择a[low]到a[m-1]为新的插入区域(即high=m-1)，否则选择a[m+1]到a[high]为新的插入区域(即low=m+1)，如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。

  
  

   
   

    
    

     
     [java] 
     
     view plain
     
     copy
     
     
     
     
     
     

    
    
   
   
   
   
/* 
 * 折半插入排序（二分插入排序） 
 * */  
public class BinaryInsertionSort {  
    public static void main(String args[]){  
        int a[]={1,4,5,7,8,2,3,6,9};  
        for(int i=1;i<a.length;i++){  
            sort(a,0,i-1,i);  
        }  
        print(a);  
    }  
    /* 
     * low,high已经排好序的插入区间，正要插入的元素*/  
    public static void sort(int a[],int low,int high,int k){  
        if(low<=high){  
            int m=(low+high)/2;  
            if(a[k]<=a[m])   sort(a,low,m-1,k);  
            else sort(a,m+1,high,k);  
        }else{  
            //备份a[k]  
            int temp=a[k];  
            //在0-k的区间内，把high+1以及以后的元素全部向后移动一个位置，在high+1的位置插入temp  
            for(int i=k;i>high+1;i--){  
                a[i]=a[i-1];  
            }  
            //插入temp  
            a[high+1]=temp;  
        }  
    }  
    public static void print(int a[]){  
        for(int i=0;i<a.length;i++)  
            System.out.print(a[i]+" ");  
    }  
}  
  
  

1.2希尔排序

2,冒泡排序

每次将最大的数排到数组的后面，假如数组的长度为n，需要比较的趟数就是n-1：每次比较中需要遍历到的元素下标为n-j-1(j为比较趟数，从o开始)。

[java]  view plain copy

1. import java.util.Scanner;  
2.   
3.   
4. public class BubbleSortDemo {  
5.     public static void bubbleSort(int a[]){  
6.         for(int j=0;j<a.length-1;j++)    //比较趟数  
7.             for(int i=0;i<a.length-j-1;i++) //一次比较中的操作  
8.                 if(a[i]>a[i+1]) {int t=a[i];a[i]=a[i+1];a[i+1]=t;}  
9.     }  
10.   
11.     public static void main(String[] args) {  
12.             Scanner scanner=new Scanner(System.in);  
13.             String numStr[]=scanner.nextLine().split(" ");  
14.             int i=0,a[]=new int[numStr.length];  
15.             for(String num:numStr){  
16.                 a[i++]=Integer.parseInt(num);  
17.             }  
18.             bubbleSort(a);  
19.             for(int x:a){  
20.                 System.out.print(x+" ");  
21.             }  
22.     }  
23.   
24. }  

2.1堆排序

[java]  view plain copy

1. import java.math.MathContext;  
2.   
3. /* 
4.  * 堆排序（最大堆树要满足一个条件就是每一个结点值都要大于或等于它的孩子结点值。在一个数组中那专业法表示为： 
5.  
6. arrays[i]>=arrays[2*i+1] && arrays[i]>=arrays[2*i+2]; ） 
7.  * 堆排序适合于大量数据的排序，堆排序的前续工作花费的时间比较多，下面我们以大根堆为例说说：  
8. 大根堆，就是根节点是最大的元素，所以每次把最大的元素选出来，与最后的一个元素交换，然后再把前n-1个元素（也就是除最后一个元素）进行一个堆的重构，让其具有大根堆的性质，重复上面的过程，直到只剩一个元素为止。这个过程其实是个选择排序的过程，但是少了交换的次数，堆排序的时间复杂度是nlogn。*/  
9. public class HeapSort {  
10.   
11.     public static void main(String args[]){  
12.         int a[]={5,8,2,3,5,7,15,9,23};  
13.         for(int i=a.length-1;i>0;i--)  
14.             sortFindMax(a,i);  
15.         print(a);  
16.     }  
17.       
18.     //计算log2(x)  
19.     public static int log2(double x){  
20.         return  (int) (Math.log(x)/Math.log(2));  
21.     }  
22.       
23.     //找出0-n之间的最大值并发到数组末尾  
24.     public static void  sortFindMax(int a[],int n){  
25.         int zhishu=log2(n+1);  
26.         int l=(int) (Math.pow(2, zhishu)-2);  
27.         for(int i=0;i<=l;i++){  
28.             check(a,i,n);  
29.         }  
30.         swap(a,0,n);  
31.     }  
32.       
33.     public static void swap(int a[],int i,int j){  
34.         int temp=a[i];  
35.         a[i]=a[j];  
36.         a[j]=temp;  
37.     }  
38.       
39.     //检测,发现不满足最大堆树，交换位置。  
40.     public static void check(int a[],int k,int n){  
41.         //先和孩子节点比较  
42.         int parent=(k-1)/2;  
43.         int left=2*k+1;  
44.         int right=2*k+2;  
45.           
46.         if(left<=n&&a[left]>a[k]) swap(a,left,k);  
47.         if(right<=n&&a[right]>a[k]) swap(a,right,k);  
48.         if(a[k]>a[parent]) swap(a,parent,k);  
49.     }  
50.       
51.     public static void print(int a[]){  
52.         for(int i=0;i<a.length;i++)  
53.             System.out.print(a[i]+" ");  
54.     }  
55. }  

3,快速排序

选取一个k值，左右扫描，找出比k大的放在k右边，比k小的放在k左边。然后再对k左右两边的分别排序。

[java]  view plain copy

1. import java.util.Scanner;  
2.   
3.   
4. public class QuickSortDemo {  
5.   
6.     public static void quickSort(int a[],int begin,int end){  
7.         int i=begin,j=end,temp;  
8.         while(i<j){  
9.             while(i<j&&a[j]>=a[i]){  //从右侧开始扫描,k在a[i]处  
10.                 j--;  
11.             }  
12.             if(i<j){   //找出第一个比k小的，交换位置  
13.                 temp=a[i];  
14.                 a[i]=a[j];  
15.                 a[j]=temp;  
16.             }  
17.             while(i<j&&a[i]<=a[j]){  //从左侧开始扫描,k在a[j]处  
18.                 i++;  
19.             }  
20.             if(i<j){ //找出第一个比k大的，交换位置  
21.                 temp=a[i];  
22.                 a[i]=a[j];  
23.                 a[j]=temp;  
24.             }  
25.         }  
26.         //k在a[i]处  
27.         if(i-1-begin>0){  
28.             quickSort(a,begin,i-1);  
29.         }  
30.         if(end-(i+1)>0){  
31.             quickSort(a,i+1,end);  
32.         }  
33.     }  
34.     public static void main(String[] args) {  
35.         // TODO Auto-generated method stub  
36.         Scanner scanner=new Scanner(System.in);  
37.         String numStr[]=scanner.nextLine().split(" ");  
38.         int i=0,a[]=new int[numStr.length];  
39.         for(String num:numStr){  
40.             a[i++]=Integer.parseInt(num);  
41.         }  
42.         quickSort(a,0,a.length-1);  
43.         for(int x:a){  
44.             System.out.print(x+" ");  
45.         }  
46.     }  
47.   
48. }  

4,归并排序

来源于分治思想，把排序划分为若干个排序的子问题，最小划分为1，比如：

1 6 9 2 5 7排序,就可以划分为[1 6 9] [2 5 7]，排好后再合并。

代码：

[java]  view plain copy

1. import java.util.Scanner;  
2.   
3. public class MergeSortDemo {  
4.     public static void merge(int a[], int p, int r, int q) {  
5.         int b[] = new int[r-p+1], c[] = new int[q-r];  
6.         // 拷贝数组  
7.         System.arraycopy(a, p, b, 0, r - p+1);  
8.         System.arraycopy(a, r+1, c, 0, q - r );  
9.         int i = 0, j = 0, t = 0;  
10.         while (i < b.length && j < c.length) {  
11.             if (b[i] < c[j]) {  
12.                 a[p + t] = b[i];  
13.                 i++;  
14.             } else {  
15.                 a[p + t] = c[j];  
16.                 j++;  
17.             }  
18.             t++;  
19.         }  
20.         while (i < b.length) {  
21.             a[p + t] = b[i];  
22.             i++;  
23.             t++;  
24.         }  
25.         while (j < c.length) {  
26.             a[p + t] = c[j];  
27.             j++;  
28.             t++;  
29.         }  
30.     }  
31.   
32.     public static void mergeSort(int a[], int p, int q) {  
33.         int mid;  
34.         if (p < q) {  
35.             mid = (p+q) / 2;  
36.             mergeSort(a,p,mid);  
37.             mergeSort(a,mid+1,q);  
38.             merge(a,p,mid,q);  
39.         }  
40.     }  
41.   
42.     public static void main(String args[]) {  
43.         Scanner scanner=new Scanner(System.in);  
44.         String numstr[]=scanner.nextLine().split(" ");  
45.         int a[]=new int[numstr.length];  
46.         int i=0;  
47.         for(String num:numstr){  
48.             a[i++]=Integer.parseInt(num);  
49.         }  
50.         mergeSort(a,0,a.length-1);  
51.         for(int x:a){  
52.             System.out.print(x+" ");  
53.         }  
54.     }  
55.   
56. }  

5,基数排序

第一步

以LSD为例，假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

0

1 81

2 22

3 73 93 43

4 14

5 55 65

6

7

8 28

9 39

第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

0

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.HashMap;  
3. import java.util.List;  
4. import java.util.Map;  
5.   
6.   
7. public class DistrSort {  
8.   
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // TODO Auto-generated method stub  
14.         int a[]={123,3456,1,3,5,8,90,12,345,15,19};  
15.         int maxW=findMaxW(a);  
16.         for(int i=1;i<=maxW;i++)  
17.             sort(a,i);  
18.         print(a);  
19.     }  
20.       
21.     /*k代表排序的位数，最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。*/  
22.     public static void sort(int a[],int k){  
23.         Map<Integer,List> map=new HashMap<Integer,List>();  
24.           
25.         //放入相应的木桶  
26.         for(int i=0;i<a.length;i++){  
27.             int w=((int)(a[i]/Math.pow(10, k-1)))%10;  
28.             List<Integer> list=map.get(w);  
29.             if(null==list){  
30.                 list=new ArrayList<Integer>();  
31.             }  
32.             list.add(a[i]);  
33.             if(null!=list)  map.put(w, list);  
34.         }  
35.           
36.         int j=0;  
37.         //将木桶解析还原成数组  
38.         for(int i=0;i<=9;i++){  
39.             List<Integer> list=map.get(i);  
40.             if(null!=list){  
41.                 for(Integer e:list)  
42.                     a[j++]=e;  
43.             }  
44.         }  
45.     }  
46.       
47.     public static void print(int a[]){  
48.         for(Integer e:a){  
49.             System.out.print(e+" ");  
50.         }  
51.     }  
52.       
53.     /*找到最大的位*/  
54.     public static int findMaxW(int a[]){  
55.         int maxW=0;  
56.         for(Integer e:a){  
57.             String num=e+"";  
58.             if(maxW<num.length()) maxW=num.length();  
59.         }  
60.         return maxW;  
61.     }  
62. }  

6，计数排序

时间复杂度是线性的，不是基于比较的排序。

1，扫描整个数组，找出最大值和最小值。

2，构造一个辅助数组，用于标记某个元素是否存在。

3，从小往大累加，算出某个元素前面有多少数。

4，按照各自的位置放入另一个数组。

[java]  view plain copy

1. /*该代码中不能存在相同的元素*/  
2. public class CountSort {  
3.   
4.     /** 
5.      * @param args 
6.      */  
7.     public static void main(String[] args) {  
8.         // TODO Auto-generated method stub  
9.         int a[]={3,78,12,345,2,90,234,56};  
10.         int b[]=sort(a);  
11.         print(b);  
12.     }  
13.   
14.     public static int[] sort(int a[]){  
15.         int b[]=new int[a.length];  
16.         int max=a[0],min=a[0];  
17.         //找出最大值和最小值  
18.         for(Integer e:a){  
19.             if(e>max) max=e;  
20.             if(e<min) min=e;  
21.         }  
22.         int k=max-min+1;  //算出极差值  
23.         int c[]=new int[k];  
24.         for(int i=0;i<a.length;i++)  
25.             c[a[i]-min]=1;  
26.           
27.         //累积计算出比自己小的数量  
28.         for(int i=1;i<c.length;i++)  
29.             c[i]+=c[i-1];  
30.           
31.         //把a[]按位置放入b[]  
32.         for(int i=0;i<a.length;i++)  
33.             b[c[a[i]-min]-1]=a[i];  
34.         return b;  
35.     }  
36.       
37.     public static void print(int a[]){  
38.         for(Integer e:a){  
39.             System.out.print(e+" ");  
40.         }  
41.     }  
42. }