经常用的排序算法-CSDN博客

本博客是整理的百度百科方面的内容综合。

在每一种方法的介绍顶部，都有百度百科的直接链接（关于本方法的介绍，百度百科真的爱了，特别的全）

　　1.直接插入排序

　　2.折半插入排序

插入排序是一种简单直观且稳定的排序算法。将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的序列。
(时间复杂度是O(n^2))

算法稳定性：插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有一个元素，就是第一个元素。比较是从有序序列的末尾开始的，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。想等元素的前后序列没有改变，从原无需序列出去的顺序就是排好后的顺序，所以插入排序是稳定的。

2.希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

时间复杂度分析：

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。

稳定性分析：

不稳定

3.冒泡算法

冒泡排序就是把小的元素往前调，把大的元素往后调

（排序算法最好的时间复杂度是O(n)最坏的时间复杂度是，平均时间复杂度是）

算法稳定性：冒泡排序就是把小的元素往前调，把大的元素往后调。比较的是相邻的两个元素比较，交换也是发生在两个元素之间。所以如果相邻的两个元素是相等的，是不会发生交换的。所以冒泡排序是一种稳定排序算法。

4.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。

时间复杂度：

选择排序的交换操作介于 0 和 (n - 1）次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1）次之间。

稳定性：不稳定

5.堆排序

　　推荐一个方法：这个方法的博客地址

　　1）建立堆

　　2）得到堆顶元素为最大元素

　　3）去掉堆顶，将堆最后一个元素放到堆顶，此时可通过一次调整重新使堆有序。

　　4）堆顶元素为最大元素。

　　5）重复步骤3，直到堆变空

时间复杂度：

堆排序的时间复杂度是nlogn级别。

稳定性：不稳定

6.快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

时间复杂度和堆排序一样nlogn级别。

稳定性不稳定

各个排序算法的代码编写

1.插入排序（java代码编写）

/**

*插入排序

*@paramarr

*@return

*/

private static int [] insertSort( int []arr){

if (arr == null || arr.length < 2 ){

return arr;

}

for (inti= 1 ;i<arr.length;i++){

for (intj=i;j> 0 ;j--){

if (arr[j]<arr[j- 1 ]){

//TODO:

int temp=arr[j];

arr[j]=arr[j- 1 ];

arr[j- 1 ]=temp;

//

} else {

//接下来是无用功

break ;

}

return arr;

}

2.希尔排序代码（java编写）

 
   public  
   static  
   void  
   main(String [] args) 
  
   { 
  
   int 
   []a={ 
   49 
   , 
   38 
   , 
   65 
   , 
   97 
   , 
   76 
   , 
   13 
   , 
   27 
   , 
   49 
   , 
   78 
   , 
   34 
   , 
   12 
   , 
   64 
   , 
   1 
   }; 
  
   System.out.println( 
   "排序之前：" 
   ); 
  
   for 
   ( 
   int  
   i= 
   0 
   ;i<a.length;i++) 
  
   { 
  
   System.out.print(a[i]+ 
   " " 
   ); 
  
   } 
  
   //希尔排序 
  
   int  
   d=a.length; 
  
   while 
   ( 
   true 
   ) 
  
   { 
  
   d=d/ 
   2 
   ; 
  
   for 
   ( 
   int  
   x= 
   0 
   ;x<d;x++) 
  
   { 
  
   for 
   ( 
   int  
   i=x+d;i<a.length;i=i+d) 
  
   { 
  
   int  
   temp=a[i]; 
  
   int  
   j; 
  
   for 
   (j=i-d;j>= 
   0 
   &&a[j]>temp;j=j-d) 
  
   { 
  
   a[j+d]=a[j]; 
  
   } 
  
   a[j+d]=temp; 
  
   } 
  
   } 
  
   if 
   (d== 
   1 
   ) 
  
   { 
  
   break 
   ; 
  
   } 
  
   } 
  
   System.out.println(); 
  
   System.out.println( 
   "排序之后：" 
   ); 
  
   for 
   ( 
   int  
   i= 
   0 
   ;i<a.length;i++) 
  
   { 
  
   System.out.print(a[i]+ 
   " " 
   ); 
  
   } 
  
   }

3.冒泡算法（java代码编写）

public static void bubbleSort(int []arr) {

for(int i =1;i< arr.length ;i++) {

for(int j = 0 ;j<arr.length-i;j++) {

if(arr[j]>arr[j+1]) {

int temp = arr[j];

arr[j]=arr[j+1]

arr[j+1]=temp;

}

}

4.选择排序：（java代码编写）

 
   public  
   static  
   void  
   selectionSort( 
   int 
   [] arr){ 
  
   for  
   ( 
   int  
   i =  
   0 
   ; i < arr.length -  
   1 
   ; i++) {     
  
   int   
   min = i; 
  
   for  
   ( 
   int  
   j = i +  
   1 
   ; j < arr.length; j++) { 
  
   if  
   (arr[min] > arr[j]) { 
  
   min = j; 
  
   } 
  
   } 
  
   if  
   (min != i) { 
  
   int  
   tmp = arr[min]; 
  
   arr[min] = arr[i]; 
  
   arr[i] = tmp; 
  
   }              
  
   } 
  
   }