经常用的排序算法

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

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

 

 

1.插入排序

　　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;
            }             
      }
 
}
 
 
posted @ 2019-08-19 15:06  LittleSwan  阅读(246)  评论(0)    收藏  举报